1 """Python abstract syntax node definitions 2 3 This file was originally 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 if isinstance(elt, (tuple, list)): 11 for elt2 in flatten(elt): 12 l.append(elt2) 13 else: 14 l.append(elt) 15 return l 16 17 def flatten_nodes(seq): 18 return [n for n in flatten(seq) if isinstance(n, Node)] 19 20 def flatten_statement(seq): 21 l = [] 22 for elt in seq: 23 if isinstance(elt, Stmt): 24 l += flatten_statement(elt) 25 else: 26 l.append(elt) 27 return l 28 29 def flatten_assignment(node): 30 l = [] 31 if isinstance(node, (AssList, AssTuple)): 32 for n in node.nodes: 33 l += flatten_assignment(n) 34 else: 35 l.append(node) 36 return l 37 38 def is_deletion(node): 39 return isinstance(node, (AssAttr, AssName)) and node.flags == "OP_DELETE" 40 41 def docstring(s): 42 if s.find("\n") != -1: 43 if s.find("'''") != -1: 44 return '"""%s"""' % s.replace('"""', '\\"\\"\\"') 45 else: 46 return "'''%s'''" % s.replace("'''", "\\'\\'\\'") 47 else: 48 return repr(s) 49 50 def indent(s): 51 return s.replace("\n", "\n\t") 52 53 def get_defaults(node): 54 55 "Return a list of (argument name, default) tuples for the 'node'." 56 57 star = (node.flags & 4 != 0) and 1 or 0 58 dstar = (node.flags & 8 != 0) and 1 or 0 59 argnames = node.argnames[:] 60 61 # Add stars to star and dstar parameters. 62 63 if star: 64 argnames[-dstar-star] = "*%s" % argnames[-dstar-star] 65 if dstar: 66 argnames[-dstar] = "**%s" % argnames[-dstar] 67 68 # Map defaults to parameters. 69 70 defaults = [None] * (len(node.argnames) - star - dstar - len(node.defaults)) + list(node.defaults) + [None] * (star + dstar) 71 return zip(argnames, defaults) 72 73 def decode_function(node): 74 return [(default and "%s=%s" % (argname, default) or argname) for (argname, default) in get_defaults(node)] 75 76 nodes = {} 77 78 class OperatorUser: 79 80 "Operator-related node." 81 82 pass 83 84 class Operator(OperatorUser): 85 86 "Operator node." 87 88 pass 89 90 class Node: 91 92 "Abstract base class for ast nodes." 93 94 def getChildren(self): 95 pass # implemented by subclasses 96 97 def __iter__(self): 98 for n in self.getChildren(): 99 yield n 100 101 def getChildNodes(self): 102 pass # implemented by subclasses 103 104 class EmptyNode(Node): 105 pass 106 107 class Expression(Node): 108 # Expression is an artificial node class to support "eval" 109 nodes["expression"] = "Expression" 110 def __init__(self, node): 111 self.node = node 112 113 def getChildren(self): 114 return self.node, 115 116 def getChildNodes(self): 117 return self.node, 118 119 def __repr__(self): 120 return "Expression(%r)" % (self.node,) 121 122 def __str__(self): 123 return str(self.node) 124 125 class Add(Node, Operator): 126 def __init__(self, leftright, lineno=None): 127 self.left = leftright[0] 128 self.right = leftright[1] 129 self.lineno = lineno 130 131 def getChildren(self): 132 return self.left, self.right 133 134 def getChildNodes(self): 135 return self.left, self.right 136 137 def __repr__(self): 138 return "Add((%r, %r))" % (self.left, self.right) 139 140 def __str__(self): 141 return "(%s + %s)" % (self.left, self.right) 142 143 class And(Node): 144 def __init__(self, nodes, lineno=None): 145 self.nodes = nodes 146 self.lineno = lineno 147 148 def getChildren(self): 149 return tuple(flatten(self.nodes)) 150 151 def getChildNodes(self): 152 nodelist = [] 153 nodelist.extend(flatten_nodes(self.nodes)) 154 return tuple(nodelist) 155 156 def __repr__(self): 157 return "And(%r)" % (self.nodes,) 158 159 def __str__(self): 160 return "(%s)" % " and ".join(map(str, self.nodes)) 161 162 class AssAttr(Node): 163 def __init__(self, expr, attrname, flags, lineno=None): 164 self.expr = expr 165 self.attrname = attrname 166 self.flags = flags 167 self.lineno = lineno 168 169 def getChildren(self): 170 return self.expr, self.attrname, self.flags 171 172 def getChildNodes(self): 173 return self.expr, 174 175 def __repr__(self): 176 return "AssAttr(%r, %r, %r)" % (self.expr, self.attrname, self.flags) 177 178 def __str__(self): 179 return "%s%s.%s" % (self.flags == "OP_DELETE" and "del " or "", self.expr, self.attrname) 180 181 class AssList(Node): 182 def __init__(self, nodes, lineno=None): 183 self.nodes = nodes 184 self.lineno = lineno 185 186 def getChildren(self): 187 return tuple(flatten(self.nodes)) 188 189 def getChildNodes(self): 190 nodelist = [] 191 nodelist.extend(flatten_nodes(self.nodes)) 192 return tuple(nodelist) 193 194 def __repr__(self): 195 return "AssList(%r)" % (self.nodes,) 196 197 def __str__(self): 198 nodes = flatten_assignment(self) 199 if nodes and is_deletion(nodes[0]): 200 return "; ".join(map(str, self.nodes)) 201 else: 202 return "[%s]" % ", ".join(map(str, self.nodes)) 203 204 class AssName(Node): 205 def __init__(self, name, flags, lineno=None): 206 self.name = name 207 self.flags = flags 208 self.lineno = lineno 209 210 def getChildren(self): 211 return self.name, self.flags 212 213 def getChildNodes(self): 214 return () 215 216 def __repr__(self): 217 return "AssName(%r, %r)" % (self.name, self.flags) 218 219 def __str__(self): 220 return "%s%s" % (self.flags == "OP_DELETE" and "del " or "", self.name) 221 222 class AssTuple(Node): 223 def __init__(self, nodes, lineno=None): 224 self.nodes = nodes 225 self.lineno = lineno 226 227 def getChildren(self): 228 return tuple(flatten(self.nodes)) 229 230 def getChildNodes(self): 231 nodelist = [] 232 nodelist.extend(flatten_nodes(self.nodes)) 233 return tuple(nodelist) 234 235 def __repr__(self): 236 return "AssTuple(%r)" % (self.nodes,) 237 238 def __str__(self): 239 nodes = flatten_assignment(self) 240 if nodes and is_deletion(nodes[0]): 241 return "; ".join(map(str, self.nodes)) 242 else: 243 return "(%s)" % ", ".join(map(str, self.nodes)) 244 245 class Assert(Node): 246 def __init__(self, test, fail, lineno=None): 247 self.test = test 248 self.fail = fail 249 self.lineno = lineno 250 251 def getChildren(self): 252 children = [] 253 children.append(self.test) 254 children.append(self.fail) 255 return tuple(children) 256 257 def getChildNodes(self): 258 nodelist = [] 259 nodelist.append(self.test) 260 if self.fail is not None: 261 nodelist.append(self.fail) 262 return tuple(nodelist) 263 264 def __repr__(self): 265 return "Assert(%r, %r)" % (self.test, self.fail) 266 267 def __str__(self): 268 return "assert %s%s" % (self.test, self.fail and ", %s" % self.fail or "") 269 270 class Assign(Node): 271 def __init__(self, nodes, expr, lineno=None): 272 self.nodes = nodes 273 self.expr = expr 274 self.lineno = lineno 275 276 def getChildren(self): 277 children = [] 278 children.extend(flatten(self.nodes)) 279 children.append(self.expr) 280 return tuple(children) 281 282 def getChildNodes(self): 283 nodelist = [] 284 nodelist.extend(flatten_nodes(self.nodes)) 285 nodelist.append(self.expr) 286 return tuple(nodelist) 287 288 def __repr__(self): 289 return "Assign(%r, %r)" % (self.nodes, self.expr) 290 291 def __str__(self): 292 return "%s = %s" % (", ".join(map(str, self.nodes)), self.expr) 293 294 class AugAssign(Node, OperatorUser): 295 def __init__(self, node, op, expr, lineno=None): 296 self.node = node 297 self.op = op 298 self.expr = expr 299 self.lineno = lineno 300 301 def getChildren(self): 302 return self.node, self.op, self.expr 303 304 def getChildNodes(self): 305 return self.node, self.expr 306 307 def __repr__(self): 308 return "AugAssign(%r, %r, %r)" % (self.node, self.op, self.expr) 309 310 def __str__(self): 311 return "%s %s %s" % (self.node, self.op, self.expr) 312 313 class Backquote(Node): 314 def __init__(self, expr, lineno=None): 315 self.expr = expr 316 self.lineno = lineno 317 318 def getChildren(self): 319 return self.expr, 320 321 def getChildNodes(self): 322 return self.expr, 323 324 def __repr__(self): 325 return "Backquote(%r)" % (self.expr,) 326 327 def __str__(self): 328 return "`%s`" % self.expr 329 330 class Bitand(Node, Operator): 331 def __init__(self, nodes, lineno=None): 332 self.nodes = nodes 333 self.lineno = lineno 334 335 def getChildren(self): 336 return tuple(flatten(self.nodes)) 337 338 def getChildNodes(self): 339 nodelist = [] 340 nodelist.extend(flatten_nodes(self.nodes)) 341 return tuple(nodelist) 342 343 def __repr__(self): 344 return "Bitand(%r)" % (self.nodes,) 345 346 def __str__(self): 347 return "(%s)" % " & ".join(map(str, self.nodes)) 348 349 class Bitor(Node, Operator): 350 def __init__(self, nodes, lineno=None): 351 self.nodes = nodes 352 self.lineno = lineno 353 354 def getChildren(self): 355 return tuple(flatten(self.nodes)) 356 357 def getChildNodes(self): 358 nodelist = [] 359 nodelist.extend(flatten_nodes(self.nodes)) 360 return tuple(nodelist) 361 362 def __repr__(self): 363 return "Bitor(%r)" % (self.nodes,) 364 365 def __str__(self): 366 return "(%s)" % " | ".join(map(str, self.nodes)) 367 368 class Bitxor(Node, Operator): 369 def __init__(self, nodes, lineno=None): 370 self.nodes = nodes 371 self.lineno = lineno 372 373 def getChildren(self): 374 return tuple(flatten(self.nodes)) 375 376 def getChildNodes(self): 377 nodelist = [] 378 nodelist.extend(flatten_nodes(self.nodes)) 379 return tuple(nodelist) 380 381 def __repr__(self): 382 return "Bitxor(%r)" % (self.nodes,) 383 384 def __str__(self): 385 return "(%s)" % " ^ ".join(map(str, self.nodes)) 386 387 class Break(Node): 388 def __init__(self, lineno=None): 389 self.lineno = lineno 390 391 def getChildren(self): 392 return () 393 394 def getChildNodes(self): 395 return () 396 397 def __repr__(self): 398 return "Break()" 399 400 def __str__(self): 401 return "break" 402 403 class CallFunc(Node): 404 def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None): 405 self.node = node 406 self.args = args 407 self.star_args = star_args 408 self.dstar_args = dstar_args 409 self.lineno = lineno 410 411 def getChildren(self): 412 children = [] 413 children.append(self.node) 414 children.extend(flatten(self.args)) 415 children.append(self.star_args) 416 children.append(self.dstar_args) 417 return tuple(children) 418 419 def getChildNodes(self): 420 nodelist = [] 421 nodelist.append(self.node) 422 nodelist.extend(flatten_nodes(self.args)) 423 if self.star_args is not None: 424 nodelist.append(self.star_args) 425 if self.dstar_args is not None: 426 nodelist.append(self.dstar_args) 427 return tuple(nodelist) 428 429 def __repr__(self): 430 args = [] 431 if self.dstar_args: 432 args.insert(0, repr(self.dstar_args)) 433 if args or self.star_args: 434 args.insert(0, repr(self.star_args)) 435 return "CallFunc(%r, %r%s)" % (self.node, self.args, args and (", %s" % ", ".join(args)) or "") 436 437 def __str__(self): 438 star_args = self.star_args and ["*%s" % self.star_args] or [] 439 dstar_args = self.dstar_args and ["**%s" % self.dstar_args] or [] 440 return "%s(%s)" % (self.node, ", ".join(map(str, tuple(self.args) + tuple(star_args) + tuple(dstar_args)))) 441 442 class Class(Node): 443 def __init__(self, name, bases, doc, code, decorators = None, lineno=None): 444 self.name = name 445 self.bases = bases 446 self.doc = doc 447 self.code = code 448 self.decorators = decorators 449 self.lineno = lineno 450 451 def getChildren(self): 452 children = [] 453 children.append(self.name) 454 children.extend(flatten(self.bases)) 455 children.append(self.doc) 456 children.append(self.code) 457 children.append(self.decorators) 458 return tuple(children) 459 460 def getChildNodes(self): 461 nodelist = [] 462 nodelist.extend(flatten_nodes(self.bases)) 463 nodelist.append(self.code) 464 if self.decorators is not None: 465 nodelist.append(self.decorators) 466 return tuple(nodelist) 467 468 def __repr__(self): 469 return "Class(%r, %r, %r, %r, %r)" % (self.name, self.bases, self.doc, self.code, self.decorators) 470 471 def __str__(self): 472 return "%sclass %s%s:%s%s\n" % ( 473 self.decorators and "%s\n" % "\n".join([("@%s" % decorator) for decorator in self.decorators]) or "", 474 self.name, 475 self.bases and "(%s)" % ", ".join(map(str, self.bases)) or "", 476 self.doc and "\n\t" + docstring(self.doc) or "", 477 indent("\n%s" % self.code) 478 ) 479 480 class Compare(Node, OperatorUser): 481 def __init__(self, expr, ops, lineno=None): 482 self.expr = expr 483 self.ops = ops 484 self.lineno = lineno 485 486 def getChildren(self): 487 children = [] 488 children.append(self.expr) 489 children.extend(flatten(self.ops)) 490 return tuple(children) 491 492 def getChildNodes(self): 493 nodelist = [] 494 nodelist.append(self.expr) 495 nodelist.extend(flatten_nodes(self.ops)) 496 return tuple(nodelist) 497 498 def __repr__(self): 499 return "Compare(%r, %r)" % (self.expr, self.ops) 500 501 def __str__(self): 502 return "%s %s" % (self.expr, " ".join([("%s %s" % op) for op in self.ops])) 503 504 class Const(Node): 505 def __init__(self, value, literal=None, lineno=None): 506 self.value = value 507 self.literal = literal 508 self.lineno = lineno 509 510 def getChildren(self): 511 return self.value, 512 513 def getChildNodes(self): 514 return () 515 516 def __repr__(self): 517 return "Const(%r, %r)" % (self.value, self.literal) 518 519 def __str__(self): 520 return repr(self.value) 521 522 class Continue(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 "Continue()" 534 535 def __str__(self): 536 return "continue" 537 538 class Decorators(Node): 539 def __init__(self, nodes, lineno=None): 540 self.nodes = nodes 541 self.lineno = lineno 542 543 def getChildren(self): 544 return tuple(flatten(self.nodes)) 545 546 def getChildNodes(self): 547 nodelist = [] 548 nodelist.extend(flatten_nodes(self.nodes)) 549 return tuple(nodelist) 550 551 def __repr__(self): 552 return "Decorators(%r)" % (self.nodes,) 553 554 def __str__(self): 555 return "\n".join([("@%s" % node) for node in self.nodes]) 556 557 class Dict(Node): 558 def __init__(self, items, lineno=None): 559 self.items = items 560 self.lineno = lineno 561 562 def getChildren(self): 563 return tuple(flatten(self.items)) 564 565 def getChildNodes(self): 566 nodelist = [] 567 nodelist.extend(flatten_nodes(self.items)) 568 return tuple(nodelist) 569 570 def __repr__(self): 571 return "Dict(%r)" % (self.items,) 572 573 def __str__(self): 574 return "{%s}" % ", ".join([("%s : %s" % (key, value)) for (key, value) in self.items]) 575 576 class Discard(Node): 577 def __init__(self, expr, lineno=None): 578 self.expr = expr 579 self.lineno = lineno 580 581 def getChildren(self): 582 return self.expr, 583 584 def getChildNodes(self): 585 return self.expr, 586 587 def __repr__(self): 588 return "Discard(%r)" % (self.expr,) 589 590 def __str__(self): 591 return str(self.expr) 592 593 class Div(Node, Operator): 594 def __init__(self, leftright, lineno=None): 595 self.left = leftright[0] 596 self.right = leftright[1] 597 self.lineno = lineno 598 599 def getChildren(self): 600 return self.left, self.right 601 602 def getChildNodes(self): 603 return self.left, self.right 604 605 def __repr__(self): 606 return "Div((%r, %r))" % (self.left, self.right) 607 608 def __str__(self): 609 return "(%s / %s)" % (self.left, self.right) 610 611 class Ellipsis(Node): 612 def __init__(self, lineno=None): 613 self.lineno = lineno 614 615 def getChildren(self): 616 return () 617 618 def getChildNodes(self): 619 return () 620 621 def __repr__(self): 622 return "Ellipsis()" 623 624 def __str__(self): 625 return "..." 626 627 class Exec(Node): 628 def __init__(self, expr, locals, globals, lineno=None): 629 self.expr = expr 630 self.locals = locals 631 self.globals = globals 632 self.lineno = lineno 633 634 def getChildren(self): 635 children = [] 636 children.append(self.expr) 637 children.append(self.locals) 638 children.append(self.globals) 639 return tuple(children) 640 641 def getChildNodes(self): 642 nodelist = [] 643 nodelist.append(self.expr) 644 if self.locals is not None: 645 nodelist.append(self.locals) 646 if self.globals is not None: 647 nodelist.append(self.globals) 648 return tuple(nodelist) 649 650 def __repr__(self): 651 return "Exec(%r, %r, %r)" % (self.expr, self.locals, self.globals) 652 653 def __str__(self): 654 return "exec %s%s%s" % (self.expr, self.locals and "in %s" % self.locals or "", 655 self.globals and ", %s" % self.globals or "") 656 657 class FloorDiv(Node, Operator): 658 def __init__(self, leftright, lineno=None): 659 self.left = leftright[0] 660 self.right = leftright[1] 661 self.lineno = lineno 662 663 def getChildren(self): 664 return self.left, self.right 665 666 def getChildNodes(self): 667 return self.left, self.right 668 669 def __repr__(self): 670 return "FloorDiv((%r, %r))" % (self.left, self.right) 671 672 def __str__(self): 673 return "(%s // %s)" % (self.left, self.right) 674 675 class For(Node): 676 def __init__(self, assign, list, body, else_, lineno=None): 677 self.assign = assign 678 self.list = list 679 self.body = body 680 self.else_ = else_ 681 self.lineno = lineno 682 683 def getChildren(self): 684 children = [] 685 children.append(self.assign) 686 children.append(self.list) 687 children.append(self.body) 688 children.append(self.else_) 689 return tuple(children) 690 691 def getChildNodes(self): 692 nodelist = [] 693 nodelist.append(self.assign) 694 nodelist.append(self.list) 695 nodelist.append(self.body) 696 if self.else_ is not None: 697 nodelist.append(self.else_) 698 return tuple(nodelist) 699 700 def __repr__(self): 701 return "For(%r, %r, %r, %r)" % (self.assign, self.list, self.body, self.else_) 702 703 def __str__(self): 704 return "for %s in %s:%s%s" % ( 705 self.assign, self.list, 706 indent("\n%s" % self.body), 707 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 708 ) 709 710 class From(Node): 711 def __init__(self, modname, names, level, lineno=None): 712 self.modname = modname 713 self.names = names 714 self.level = level 715 self.lineno = lineno 716 717 def getChildren(self): 718 return self.modname, self.names, self.level 719 720 def getChildNodes(self): 721 return () 722 723 def __repr__(self): 724 return "From(%r, %r, %r)" % (self.modname, self.names, self.level) 725 726 def __str__(self): 727 return "from %s import %s" % (self.modname, 728 ", ".join([(alias and "%s as %s" % (name, alias) or name) for (name, alias) in self.names])) 729 730 class Function(Node): 731 def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None): 732 self.decorators = decorators 733 self.name = name 734 self.argnames = argnames 735 self.defaults = defaults 736 self.flags = flags 737 self.doc = doc 738 self.code = code 739 self.lineno = lineno 740 self.varargs = self.kwargs = None 741 if flags & CO_VARARGS: 742 self.varargs = 1 743 if flags & CO_VARKEYWORDS: 744 self.kwargs = 1 745 746 def getChildren(self): 747 children = [] 748 children.append(self.decorators) 749 children.append(self.name) 750 children.append(self.argnames) 751 children.extend(flatten(self.defaults)) 752 children.append(self.flags) 753 children.append(self.doc) 754 children.append(self.code) 755 return tuple(children) 756 757 def getChildNodes(self): 758 nodelist = [] 759 if self.decorators is not None: 760 nodelist.append(self.decorators) 761 nodelist.extend(flatten_nodes(self.defaults)) 762 nodelist.append(self.code) 763 return tuple(nodelist) 764 765 def __repr__(self): 766 return "Function(%r, %r, %r, %r, %r, %r, %r)" % (self.decorators, self.name, self.argnames, self.defaults, self.flags, self.doc, self.code) 767 768 def __str__(self): 769 parameters = decode_function(self) 770 771 return "%sdef %s(%s):%s%s\n" % ( 772 self.decorators and "%s\n" % "\n".join([("@%s" % decorator) for decorator in self.decorators]) or "", 773 self.name, 774 ", ".join(parameters), 775 self.doc and "\n\n\t%s\n" % docstring(self.doc) or "", 776 indent("\n%s" % self.code) 777 ) 778 779 class GenExpr(Node): 780 def __init__(self, code, lineno=None): 781 self.code = code 782 self.lineno = lineno 783 self.argnames = ['.0'] 784 self.varargs = self.kwargs = None 785 786 def getChildren(self): 787 return self.code, 788 789 def getChildNodes(self): 790 return self.code, 791 792 def __repr__(self): 793 return "GenExpr(%r)" % (self.code,) 794 795 def __str__(self): 796 return str(self.code) 797 798 class GenExprFor(Node): 799 def __init__(self, assign, iter, ifs, lineno=None): 800 self.assign = assign 801 self.iter = iter 802 self.ifs = ifs 803 self.lineno = lineno 804 self.is_outmost = False 805 806 def getChildren(self): 807 children = [] 808 children.append(self.assign) 809 children.append(self.iter) 810 children.extend(flatten(self.ifs)) 811 return tuple(children) 812 813 def getChildNodes(self): 814 nodelist = [] 815 nodelist.append(self.assign) 816 nodelist.append(self.iter) 817 nodelist.extend(flatten_nodes(self.ifs)) 818 return tuple(nodelist) 819 820 def __repr__(self): 821 return "GenExprFor(%r, %r, %r)" % (self.assign, self.iter, self.ifs) 822 823 def __str__(self): 824 return "for %s in %s%s" % ( 825 self.assign, self.iter, 826 self.ifs and " ".join(map(str, self.ifs)) or "" 827 ) 828 829 class GenExprIf(Node): 830 def __init__(self, test, lineno=None): 831 self.test = test 832 self.lineno = lineno 833 834 def getChildren(self): 835 return self.test, 836 837 def getChildNodes(self): 838 return self.test, 839 840 def __repr__(self): 841 return "GenExprIf(%r)" % (self.test,) 842 843 def __str__(self): 844 return "if %s" % self.test 845 846 class GenExprInner(Node): 847 def __init__(self, expr, quals, lineno=None): 848 self.expr = expr 849 self.quals = quals 850 self.lineno = lineno 851 852 def getChildren(self): 853 children = [] 854 children.append(self.expr) 855 children.extend(flatten(self.quals)) 856 return tuple(children) 857 858 def getChildNodes(self): 859 nodelist = [] 860 nodelist.append(self.expr) 861 nodelist.extend(flatten_nodes(self.quals)) 862 return tuple(nodelist) 863 864 def __repr__(self): 865 return "GenExprInner(%r, %r)" % (self.expr, self.quals) 866 867 def __str__(self): 868 return "%s %s" % (self.expr, " ".join(map(str, self.quals))) 869 870 class Getattr(Node): 871 def __init__(self, expr, attrname, lineno=None): 872 self.expr = expr 873 self.attrname = attrname 874 self.lineno = lineno 875 876 def getChildren(self): 877 return self.expr, self.attrname 878 879 def getChildNodes(self): 880 return self.expr, 881 882 def __repr__(self): 883 return "Getattr(%r, %r)" % (self.expr, self.attrname) 884 885 def __str__(self): 886 return "%s.%s" % (self.expr, self.attrname) 887 888 class Global(Node): 889 def __init__(self, names, lineno=None): 890 self.names = names 891 self.lineno = lineno 892 893 def getChildren(self): 894 return self.names, 895 896 def getChildNodes(self): 897 return () 898 899 def __repr__(self): 900 return "Global(%r)" % (self.names,) 901 902 def __str__(self): 903 return "global %s" % ", ".join(map(str, self.names)) 904 905 class If(Node): 906 def __init__(self, tests, else_, lineno=None): 907 self.tests = tests 908 self.else_ = else_ 909 self.lineno = lineno 910 911 def getChildren(self): 912 children = [] 913 children.extend(flatten(self.tests)) 914 children.append(self.else_) 915 return tuple(children) 916 917 def getChildNodes(self): 918 nodelist = [] 919 nodelist.extend(flatten_nodes(self.tests)) 920 if self.else_ is not None: 921 nodelist.append(self.else_) 922 return tuple(nodelist) 923 924 def __repr__(self): 925 return "If(%r, %r)" % (self.tests, self.else_) 926 927 def __str__(self): 928 tests = [("%sif %s:%s" % (i > 0 and "el" or "", test, indent("\n%s" % body))) for (i, (test, body)) in enumerate(self.tests)] 929 return "%s%s" % ( 930 "\n".join(tests), 931 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 932 ) 933 934 class IfExp(Node): 935 def __init__(self, test, then, else_, lineno=None): 936 self.test = test 937 self.then = then 938 self.else_ = else_ 939 self.lineno = lineno 940 941 def getChildren(self): 942 return self.test, self.then, self.else_ 943 944 def getChildNodes(self): 945 return self.test, self.then, self.else_ 946 947 def __repr__(self): 948 return "IfExp(%r, %r, %r)" % (self.test, self.then, self.else_) 949 950 def __str__(self): 951 return "%s if %s else %s" % (self.then, self.test, self.else_) 952 953 class Import(Node): 954 def __init__(self, names, lineno=None): 955 self.names = names 956 self.lineno = lineno 957 958 def getChildren(self): 959 return self.names, 960 961 def getChildNodes(self): 962 return () 963 964 def __repr__(self): 965 return "Import(%r)" % (self.names,) 966 967 def __str__(self): 968 return "import %s" % ( 969 ", ".join([(alias and "%s as %s" % (name, alias) or name) for (name, alias) in self.names])) 970 971 class Invert(Node, Operator): 972 def __init__(self, expr, lineno=None): 973 self.expr = expr 974 self.lineno = lineno 975 976 def getChildren(self): 977 return self.expr, 978 979 def getChildNodes(self): 980 return self.expr, 981 982 def __repr__(self): 983 return "Invert(%r)" % (self.expr,) 984 985 def __str__(self): 986 return "~%s" % self.expr 987 988 class Keyword(Node): 989 def __init__(self, name, expr, lineno=None): 990 self.name = name 991 self.expr = expr 992 self.lineno = lineno 993 994 def getChildren(self): 995 return self.name, self.expr 996 997 def getChildNodes(self): 998 return self.expr, 999 1000 def __repr__(self): 1001 return "Keyword(%r, %r)" % (self.name, self.expr) 1002 1003 def __str__(self): 1004 return "%s=%s" % (self.name, self.expr) 1005 1006 class Lambda(Node): 1007 def __init__(self, argnames, defaults, flags, code, lineno=None): 1008 self.argnames = argnames 1009 self.defaults = defaults 1010 self.flags = flags 1011 self.code = code 1012 self.lineno = lineno 1013 self.varargs = self.kwargs = None 1014 if flags & CO_VARARGS: 1015 self.varargs = 1 1016 if flags & CO_VARKEYWORDS: 1017 self.kwargs = 1 1018 1019 def getChildren(self): 1020 children = [] 1021 children.append(self.argnames) 1022 children.extend(flatten(self.defaults)) 1023 children.append(self.flags) 1024 children.append(self.code) 1025 return tuple(children) 1026 1027 def getChildNodes(self): 1028 nodelist = [] 1029 nodelist.extend(flatten_nodes(self.defaults)) 1030 nodelist.append(self.code) 1031 return tuple(nodelist) 1032 1033 def __repr__(self): 1034 return "Lambda(%r, %r, %r, %r)" % (self.argnames, self.defaults, self.flags, self.code) 1035 1036 def __str__(self): 1037 parameters = decode_function(self) 1038 return "lambda %s: %s" % (", ".join(parameters), self.code) 1039 1040 class LeftShift(Node, Operator): 1041 def __init__(self, leftright, lineno=None): 1042 self.left = leftright[0] 1043 self.right = leftright[1] 1044 self.lineno = lineno 1045 1046 def getChildren(self): 1047 return self.left, self.right 1048 1049 def getChildNodes(self): 1050 return self.left, self.right 1051 1052 def __repr__(self): 1053 return "LeftShift((%r, %r))" % (self.left, self.right) 1054 1055 def __str__(self): 1056 return "(%s << %s)" % (self.left, self.right) 1057 1058 class List(Node): 1059 def __init__(self, nodes, lineno=None): 1060 self.nodes = nodes 1061 self.lineno = lineno 1062 1063 def getChildren(self): 1064 return tuple(flatten(self.nodes)) 1065 1066 def getChildNodes(self): 1067 nodelist = [] 1068 nodelist.extend(flatten_nodes(self.nodes)) 1069 return tuple(nodelist) 1070 1071 def __repr__(self): 1072 return "List(%r)" % (self.nodes,) 1073 1074 def __str__(self): 1075 return "[%s]" % ", ".join(map(str, self.nodes)) 1076 1077 class ListComp(Node): 1078 def __init__(self, expr, quals, lineno=None): 1079 self.expr = expr 1080 self.quals = quals 1081 self.lineno = lineno 1082 1083 def getChildren(self): 1084 children = [] 1085 children.append(self.expr) 1086 children.extend(flatten(self.quals)) 1087 return tuple(children) 1088 1089 def getChildNodes(self): 1090 nodelist = [] 1091 nodelist.append(self.expr) 1092 nodelist.extend(flatten_nodes(self.quals)) 1093 return tuple(nodelist) 1094 1095 def __repr__(self): 1096 return "ListComp(%r, %r)" % (self.expr, self.quals) 1097 1098 def __str__(self): 1099 return "[%s %s]" % (self.expr, " ".join(map(str, self.quals))) 1100 1101 class ListCompFor(Node): 1102 def __init__(self, assign, list, ifs, lineno=None): 1103 self.assign = assign 1104 self.list = list 1105 self.ifs = ifs 1106 self.lineno = lineno 1107 1108 def getChildren(self): 1109 children = [] 1110 children.append(self.assign) 1111 children.append(self.list) 1112 children.extend(flatten(self.ifs)) 1113 return tuple(children) 1114 1115 def getChildNodes(self): 1116 nodelist = [] 1117 nodelist.append(self.assign) 1118 nodelist.append(self.list) 1119 nodelist.extend(flatten_nodes(self.ifs)) 1120 return tuple(nodelist) 1121 1122 def __repr__(self): 1123 return "ListCompFor(%r, %r, %r)" % (self.assign, self.list, self.ifs) 1124 1125 def __str__(self): 1126 return "for %s in %s%s" % ( 1127 self.assign, self.list, 1128 self.ifs and " ".join(map(str, self.ifs)) or "" 1129 ) 1130 1131 class ListCompIf(Node): 1132 def __init__(self, test, lineno=None): 1133 self.test = test 1134 self.lineno = lineno 1135 1136 def getChildren(self): 1137 return self.test, 1138 1139 def getChildNodes(self): 1140 return self.test, 1141 1142 def __repr__(self): 1143 return "ListCompIf(%r)" % (self.test,) 1144 1145 def __str__(self): 1146 return " if %s" % self.test 1147 1148 class SetComp(Node): 1149 def __init__(self, expr, quals, lineno=None): 1150 self.expr = expr 1151 self.quals = quals 1152 self.lineno = lineno 1153 1154 def getChildren(self): 1155 children = [] 1156 children.append(self.expr) 1157 children.extend(flatten(self.quals)) 1158 return tuple(children) 1159 1160 def getChildNodes(self): 1161 nodelist = [] 1162 nodelist.append(self.expr) 1163 nodelist.extend(flatten_nodes(self.quals)) 1164 return tuple(nodelist) 1165 1166 def __repr__(self): 1167 return "SetComp(%r, %r)" % (self.expr, self.quals) 1168 1169 def __str__(self): 1170 return "{%s %s}" % (self.expr, " ".join(map(str, self.quals))) 1171 1172 class DictComp(Node): 1173 def __init__(self, key, value, quals, lineno=None): 1174 self.key = key 1175 self.value = value 1176 self.quals = quals 1177 self.lineno = lineno 1178 1179 def getChildren(self): 1180 children = [] 1181 children.append(self.key) 1182 children.append(self.value) 1183 children.extend(flatten(self.quals)) 1184 return tuple(children) 1185 1186 def getChildNodes(self): 1187 nodelist = [] 1188 nodelist.append(self.key) 1189 nodelist.append(self.value) 1190 nodelist.extend(flatten_nodes(self.quals)) 1191 return tuple(nodelist) 1192 1193 def __repr__(self): 1194 return "DictComp(%r, %r, %r)" % (self.key, self.value, self.quals) 1195 1196 def __str__(self): 1197 return "{%s : %s %s}" % (self.key, self.value, " ".join(map(str, self.quals))) 1198 1199 class Mod(Node, Operator): 1200 def __init__(self, leftright, lineno=None): 1201 self.left = leftright[0] 1202 self.right = leftright[1] 1203 self.lineno = lineno 1204 1205 def getChildren(self): 1206 return self.left, self.right 1207 1208 def getChildNodes(self): 1209 return self.left, self.right 1210 1211 def __repr__(self): 1212 return "Mod((%r, %r))" % (self.left, self.right) 1213 1214 def __str__(self): 1215 return "(%s %% %s)" % (self.left, self.right) 1216 1217 class Module(Node): 1218 def __init__(self, doc, node, lineno=None): 1219 self.doc = doc 1220 self.node = node 1221 self.lineno = lineno 1222 1223 def getChildren(self): 1224 return self.doc, self.node 1225 1226 def getChildNodes(self): 1227 return self.node, 1228 1229 def __repr__(self): 1230 return "Module(%r, %r)" % (self.doc, self.node) 1231 1232 def __str__(self): 1233 return "%s%s" % (self.doc and "%s\n\n" % docstring(self.doc) or "", self.node) 1234 1235 class Mul(Node, Operator): 1236 def __init__(self, leftright, lineno=None): 1237 self.left = leftright[0] 1238 self.right = leftright[1] 1239 self.lineno = lineno 1240 1241 def getChildren(self): 1242 return self.left, self.right 1243 1244 def getChildNodes(self): 1245 return self.left, self.right 1246 1247 def __repr__(self): 1248 return "Mul((%r, %r))" % (self.left, self.right) 1249 1250 def __str__(self): 1251 return "(%s * %s)" % (self.left, self.right) 1252 1253 class Name(Node): 1254 def __init__(self, name, lineno=None): 1255 self.name = name 1256 self.lineno = lineno 1257 1258 def getChildren(self): 1259 return self.name, 1260 1261 def getChildNodes(self): 1262 return () 1263 1264 def __repr__(self): 1265 return "Name(%r)" % (self.name,) 1266 1267 def __str__(self): 1268 return str(self.name) 1269 1270 class Not(Node): 1271 def __init__(self, expr, lineno=None): 1272 self.expr = expr 1273 self.lineno = lineno 1274 1275 def getChildren(self): 1276 return self.expr, 1277 1278 def getChildNodes(self): 1279 return self.expr, 1280 1281 def __repr__(self): 1282 return "Not(%r)" % (self.expr,) 1283 1284 def __str__(self): 1285 return "not %s" % self.expr 1286 1287 class Or(Node): 1288 def __init__(self, nodes, lineno=None): 1289 self.nodes = nodes 1290 self.lineno = lineno 1291 1292 def getChildren(self): 1293 return tuple(flatten(self.nodes)) 1294 1295 def getChildNodes(self): 1296 nodelist = [] 1297 nodelist.extend(flatten_nodes(self.nodes)) 1298 return tuple(nodelist) 1299 1300 def __repr__(self): 1301 return "Or(%r)" % (self.nodes,) 1302 1303 def __str__(self): 1304 return "(%s)" % " or ".join(map(str, self.nodes)) 1305 1306 class Pass(Node): 1307 def __init__(self, lineno=None): 1308 self.lineno = lineno 1309 1310 def getChildren(self): 1311 return () 1312 1313 def getChildNodes(self): 1314 return () 1315 1316 def __repr__(self): 1317 return "Pass()" 1318 1319 def __str__(self): 1320 return "pass" 1321 1322 class Power(Node, Operator): 1323 def __init__(self, leftright, lineno=None): 1324 self.left = leftright[0] 1325 self.right = leftright[1] 1326 self.lineno = lineno 1327 1328 def getChildren(self): 1329 return self.left, self.right 1330 1331 def getChildNodes(self): 1332 return self.left, self.right 1333 1334 def __repr__(self): 1335 return "Power((%r, %r))" % (self.left, self.right) 1336 1337 def __str__(self): 1338 return "(%s ** %s)" % (self.left, self.right) 1339 1340 class Print(Node): 1341 def __init__(self, nodes, dest, lineno=None): 1342 self.nodes = nodes 1343 self.dest = dest 1344 self.lineno = lineno 1345 1346 def getChildren(self): 1347 children = [] 1348 children.extend(flatten(self.nodes)) 1349 children.append(self.dest) 1350 return tuple(children) 1351 1352 def getChildNodes(self): 1353 nodelist = [] 1354 nodelist.extend(flatten_nodes(self.nodes)) 1355 if self.dest is not None: 1356 nodelist.append(self.dest) 1357 return tuple(nodelist) 1358 1359 def __repr__(self): 1360 return "Print(%r, %r)" % (self.nodes, self.dest) 1361 1362 def __str__(self): 1363 dest = self.dest and [">>%s" % self.dest] or [] 1364 return "print %s," % ", ".join(map(str, dest + self.nodes)) 1365 1366 class Printnl(Node): 1367 def __init__(self, nodes, dest, lineno=None): 1368 self.nodes = nodes 1369 self.dest = dest 1370 self.lineno = lineno 1371 1372 def getChildren(self): 1373 children = [] 1374 children.extend(flatten(self.nodes)) 1375 children.append(self.dest) 1376 return tuple(children) 1377 1378 def getChildNodes(self): 1379 nodelist = [] 1380 nodelist.extend(flatten_nodes(self.nodes)) 1381 if self.dest is not None: 1382 nodelist.append(self.dest) 1383 return tuple(nodelist) 1384 1385 def __repr__(self): 1386 return "Printnl(%r, %r)" % (self.nodes, self.dest) 1387 1388 def __str__(self): 1389 dest = self.dest and [">>%s" % self.dest] or [] 1390 return "print %s" % ", ".join(map(str, dest + self.nodes)) 1391 1392 class Raise(Node): 1393 def __init__(self, expr1, expr2, expr3, lineno=None): 1394 self.expr1 = expr1 1395 self.expr2 = expr2 1396 self.expr3 = expr3 1397 self.lineno = lineno 1398 1399 def getChildren(self): 1400 children = [] 1401 children.append(self.expr1) 1402 children.append(self.expr2) 1403 children.append(self.expr3) 1404 return tuple(children) 1405 1406 def getChildNodes(self): 1407 nodelist = [] 1408 if self.expr1 is not None: 1409 nodelist.append(self.expr1) 1410 if self.expr2 is not None: 1411 nodelist.append(self.expr2) 1412 if self.expr3 is not None: 1413 nodelist.append(self.expr3) 1414 return tuple(nodelist) 1415 1416 def __repr__(self): 1417 return "Raise(%r, %r, %r)" % (self.expr1, self.expr2, self.expr3) 1418 1419 def __str__(self): 1420 args = self.expr1 and [self.expr1] or [] 1421 args += self.expr2 and [self.expr2] or [] 1422 args += self.expr3 and [self.expr3] or [] 1423 return "raise %s" % ", ".join(map(str, args)) 1424 1425 class Return(Node): 1426 def __init__(self, value, lineno=None): 1427 self.value = value 1428 self.lineno = lineno 1429 1430 def getChildren(self): 1431 return self.value, 1432 1433 def getChildNodes(self): 1434 return self.value, 1435 1436 def __repr__(self): 1437 return "Return(%r)" % (self.value,) 1438 1439 def __str__(self): 1440 return "return %s" % self.value 1441 1442 class RightShift(Node, Operator): 1443 def __init__(self, leftright, lineno=None): 1444 self.left = leftright[0] 1445 self.right = leftright[1] 1446 self.lineno = lineno 1447 1448 def getChildren(self): 1449 return self.left, self.right 1450 1451 def getChildNodes(self): 1452 return self.left, self.right 1453 1454 def __repr__(self): 1455 return "RightShift((%r, %r))" % (self.left, self.right) 1456 1457 def __str__(self): 1458 return "(%s >> %s)" % (self.left, self.right) 1459 1460 class Set(Node): 1461 def __init__(self, nodes, lineno=None): 1462 self.nodes = nodes 1463 self.lineno = lineno 1464 1465 def getChildren(self): 1466 return tuple(flatten(self.nodes)) 1467 1468 def getChildNodes(self): 1469 nodelist = [] 1470 nodelist.extend(flatten_nodes(self.nodes)) 1471 return tuple(nodelist) 1472 1473 def __repr__(self): 1474 return "Set(%r)" % (self.nodes,) 1475 1476 def __str__(self): 1477 return "{%s}" % ", ".join(map(str, self.nodes)) 1478 1479 class Slice(Node, OperatorUser): 1480 def __init__(self, expr, flags, lower, upper, lineno=None): 1481 self.expr = expr 1482 self.flags = flags 1483 self.lower = lower 1484 self.upper = upper 1485 self.lineno = lineno 1486 1487 def getChildren(self): 1488 children = [] 1489 children.append(self.expr) 1490 children.append(self.flags) 1491 children.append(self.lower) 1492 children.append(self.upper) 1493 return tuple(children) 1494 1495 def getChildNodes(self): 1496 nodelist = [] 1497 nodelist.append(self.expr) 1498 if self.lower is not None: 1499 nodelist.append(self.lower) 1500 if self.upper is not None: 1501 nodelist.append(self.upper) 1502 return tuple(nodelist) 1503 1504 def __repr__(self): 1505 return "Slice(%r, %r, %r, %r)" % (self.expr, self.flags, self.lower, self.upper) 1506 1507 def __str__(self): 1508 args = [self.lower or "", self.upper or ""] 1509 return "%s%s[%s]" % (self.flags == "OP_DELETE" and "del " or "", self.expr, ":".join(map(str, args))) 1510 1511 class Sliceobj(Node): 1512 def __init__(self, nodes, lineno=None): 1513 self.nodes = nodes 1514 self.lineno = lineno 1515 1516 def getChildren(self): 1517 return tuple(flatten(self.nodes)) 1518 1519 def getChildNodes(self): 1520 nodelist = [] 1521 nodelist.extend(flatten_nodes(self.nodes)) 1522 return tuple(nodelist) 1523 1524 def __repr__(self): 1525 return "Sliceobj(%r)" % (self.nodes,) 1526 1527 def __str__(self): 1528 return ":".join(map(str, self.nodes)) 1529 1530 class Stmt(Node): 1531 def __init__(self, nodes, lineno=None): 1532 self.nodes = nodes 1533 self.lineno = lineno 1534 1535 def getChildren(self): 1536 return tuple(flatten(self.nodes)) 1537 1538 def getChildNodes(self): 1539 nodelist = [] 1540 nodelist.extend(flatten_nodes(self.nodes)) 1541 return tuple(nodelist) 1542 1543 def __repr__(self): 1544 return "Stmt(%r)" % (self.nodes,) 1545 1546 def __str__(self): 1547 return "\n".join(map(str, flatten_statement(self.nodes))) 1548 1549 class Sub(Node, Operator): 1550 def __init__(self, leftright, lineno=None): 1551 self.left = leftright[0] 1552 self.right = leftright[1] 1553 self.lineno = lineno 1554 1555 def getChildren(self): 1556 return self.left, self.right 1557 1558 def getChildNodes(self): 1559 return self.left, self.right 1560 1561 def __repr__(self): 1562 return "Sub((%r, %r))" % (self.left, self.right) 1563 1564 def __str__(self): 1565 return "(%s - %s)" % (self.left, self.right) 1566 1567 class Subscript(Node, OperatorUser): 1568 def __init__(self, expr, flags, subs, lineno=None): 1569 self.expr = expr 1570 self.flags = flags 1571 self.subs = subs 1572 self.lineno = lineno 1573 1574 def getChildren(self): 1575 children = [] 1576 children.append(self.expr) 1577 children.append(self.flags) 1578 children.extend(flatten(self.subs)) 1579 return tuple(children) 1580 1581 def getChildNodes(self): 1582 nodelist = [] 1583 nodelist.append(self.expr) 1584 nodelist.extend(flatten_nodes(self.subs)) 1585 return tuple(nodelist) 1586 1587 def __repr__(self): 1588 return "Subscript(%r, %r, %r)" % (self.expr, self.flags, self.subs) 1589 1590 def __str__(self): 1591 return "%s%s[%s]" % (self.flags == "OP_DELETE" and "del " or "", self.expr, ",".join(map(str, self.subs))) 1592 1593 class TryExcept(Node): 1594 def __init__(self, body, handlers, else_, lineno=None): 1595 self.body = body 1596 self.handlers = handlers 1597 self.else_ = else_ 1598 self.lineno = lineno 1599 1600 def getChildren(self): 1601 children = [] 1602 children.append(self.body) 1603 children.extend(flatten(self.handlers)) 1604 children.append(self.else_) 1605 return tuple(children) 1606 1607 def getChildNodes(self): 1608 nodelist = [] 1609 nodelist.append(self.body) 1610 nodelist.extend(flatten_nodes(self.handlers)) 1611 if self.else_ is not None: 1612 nodelist.append(self.else_) 1613 return tuple(nodelist) 1614 1615 def __repr__(self): 1616 return "TryExcept(%r, %r, %r)" % (self.body, self.handlers, self.else_) 1617 1618 def __str__(self): 1619 handlers = [ 1620 ("\nexcept%s%s:%s" % (spec and " %s" % spec or "", assign and ", %s" % assign or "", indent("\n%s" % statement))) 1621 for (spec, assign, statement) in self.handlers 1622 ] 1623 1624 return "try:%s%s%s" % ( 1625 indent("\n%s" % self.body), 1626 "".join(handlers), 1627 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1628 ) 1629 1630 class TryFinally(Node): 1631 def __init__(self, body, final, lineno=None): 1632 self.body = body 1633 self.final = final 1634 self.lineno = lineno 1635 1636 def getChildren(self): 1637 return self.body, self.final 1638 1639 def getChildNodes(self): 1640 return self.body, self.final 1641 1642 def __repr__(self): 1643 return "TryFinally(%r, %r)" % (self.body, self.final) 1644 1645 def __str__(self): 1646 return "try:%s\nfinally:%s" % ( 1647 indent("\n%s" % self.body), 1648 indent("\n%s" % self.final) 1649 ) 1650 1651 class Tuple(Node): 1652 def __init__(self, nodes, lineno=None): 1653 self.nodes = nodes 1654 self.lineno = lineno 1655 1656 def getChildren(self): 1657 return tuple(flatten(self.nodes)) 1658 1659 def getChildNodes(self): 1660 nodelist = [] 1661 nodelist.extend(flatten_nodes(self.nodes)) 1662 return tuple(nodelist) 1663 1664 def __repr__(self): 1665 return "Tuple(%r)" % (self.nodes,) 1666 1667 def __str__(self): 1668 return "(%s)" % ", ".join(map(str, self.nodes)) 1669 1670 class UnaryAdd(Node, Operator): 1671 def __init__(self, expr, lineno=None): 1672 self.expr = expr 1673 self.lineno = lineno 1674 1675 def getChildren(self): 1676 return self.expr, 1677 1678 def getChildNodes(self): 1679 return self.expr, 1680 1681 def __repr__(self): 1682 return "UnaryAdd(%r)" % (self.expr,) 1683 1684 def __str__(self): 1685 return "+%s" % self.expr 1686 1687 class UnarySub(Node, Operator): 1688 def __init__(self, expr, lineno=None): 1689 self.expr = expr 1690 self.lineno = lineno 1691 1692 def getChildren(self): 1693 return self.expr, 1694 1695 def getChildNodes(self): 1696 return self.expr, 1697 1698 def __repr__(self): 1699 return "UnarySub(%r)" % (self.expr,) 1700 1701 def __str__(self): 1702 return "-%s" % self.expr 1703 1704 class While(Node): 1705 def __init__(self, test, body, else_, lineno=None): 1706 self.test = test 1707 self.body = body 1708 self.else_ = else_ 1709 self.lineno = lineno 1710 1711 def getChildren(self): 1712 children = [] 1713 children.append(self.test) 1714 children.append(self.body) 1715 children.append(self.else_) 1716 return tuple(children) 1717 1718 def getChildNodes(self): 1719 nodelist = [] 1720 nodelist.append(self.test) 1721 nodelist.append(self.body) 1722 if self.else_ is not None: 1723 nodelist.append(self.else_) 1724 return tuple(nodelist) 1725 1726 def __repr__(self): 1727 return "While(%r, %r, %r)" % (self.test, self.body, self.else_) 1728 1729 def __str__(self): 1730 return "while %s:%s%s" % ( 1731 self.test, 1732 indent("\n%s" % self.body), 1733 self.else_ and "\nelse:%s" % indent("\n%s" % self.else_) or "" 1734 ) 1735 1736 class With(Node): 1737 def __init__(self, expr, vars, body, lineno=None): 1738 self.expr = expr 1739 self.vars = vars 1740 self.body = body 1741 self.lineno = lineno 1742 1743 def getChildren(self): 1744 children = [] 1745 children.append(self.expr) 1746 children.append(self.vars) 1747 children.append(self.body) 1748 return tuple(children) 1749 1750 def getChildNodes(self): 1751 nodelist = [] 1752 nodelist.append(self.expr) 1753 if self.vars is not None: 1754 nodelist.append(self.vars) 1755 nodelist.append(self.body) 1756 return tuple(nodelist) 1757 1758 def __repr__(self): 1759 return "With(%r, %r, %r)" % (self.expr, self.vars, self.body) 1760 1761 def __str__(self): 1762 return "with %s%s:%s" % ( 1763 self.expr, 1764 self.vars and " as %s" % ", ".join(map(str, self.vars)), 1765 indent("\n%s" % self.body), 1766 ) 1767 1768 class Yield(Node): 1769 def __init__(self, value, lineno=None): 1770 self.value = value 1771 self.lineno = lineno 1772 1773 def getChildren(self): 1774 return self.value, 1775 1776 def getChildNodes(self): 1777 return self.value, 1778 1779 def __repr__(self): 1780 return "Yield(%r)" % (self.value,) 1781 1782 def __str__(self): 1783 return "yield %s" % self.value 1784 1785 for name, obj in globals().items(): 1786 if isinstance(obj, type) and issubclass(obj, Node): 1787 nodes[name.lower()] = obj