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