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