Lib/compiler/ast.py

   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