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, 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, (left, right), lineno=None):

   435         self.left = left

   436         self.right = right

   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, (left, right), lineno=None):

   489         self.left = left

   490         self.right = right

   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 

   564     def getChildren(self):

   565         children = []

   566         children.append(self.decorators)

   567         children.append(self.name)

   568         children.append(self.argnames)

   569         children.extend(flatten(self.defaults))

   570         children.append(self.flags)

   571         children.append(self.doc)

   572         children.append(self.code)

   573         return tuple(children)

   574 

   575     def getChildNodes(self):

   576         nodelist = []

   577         if self.decorators is not None:

   578             nodelist.append(self.decorators)

   579         nodelist.extend(flatten_nodes(self.defaults))

   580         nodelist.append(self.code)

   581         return tuple(nodelist)

   582 

   583     def __repr__(self):

   584         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))

   585 

   586 class GenExpr(Node):

   587     def __init__(self, code, lineno=None):

   588         self.code = code

   589         self.lineno = lineno

   590         self.argnames = ['.0']

   591         self.varargs = self.kwargs = None

   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 

   611     def getChildren(self):

   612         children = []

   613         children.append(self.assign)

   614         children.append(self.iter)

   615         children.extend(flatten(self.ifs))

   616         return tuple(children)

   617 

   618     def getChildNodes(self):

   619         nodelist = []

   620         nodelist.append(self.assign)

   621         nodelist.append(self.iter)

   622         nodelist.extend(flatten_nodes(self.ifs))

   623         return tuple(nodelist)

   624 

   625     def __repr__(self):

   626         return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))

   627 

   628 class GenExprIf(Node):

   629     def __init__(self, test, lineno=None):

   630         self.test = test

   631         self.lineno = lineno

   632 

   633     def getChildren(self):

   634         return self.test,

   635 

   636     def getChildNodes(self):

   637         return self.test,

   638 

   639     def __repr__(self):

   640         return "GenExprIf(%s)" % (repr(self.test),)

   641 

   642 class GenExprInner(Node):

   643     def __init__(self, expr, quals, lineno=None):

   644         self.expr = expr

   645         self.quals = quals

   646         self.lineno = lineno

   647 

   648     def getChildren(self):

   649         children = []

   650         children.append(self.expr)

   651         children.extend(flatten(self.quals))

   652         return tuple(children)

   653 

   654     def getChildNodes(self):

   655         nodelist = []

   656         nodelist.append(self.expr)

   657         nodelist.extend(flatten_nodes(self.quals))

   658         return tuple(nodelist)

   659 

   660     def __repr__(self):

   661         return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))

   662 

   663 class Getattr(Node):

   664     def __init__(self, expr, attrname, lineno=None):

   665         self.expr = expr

   666         self.attrname = attrname

   667         self.lineno = lineno

   668 

   669     def getChildren(self):

   670         return self.expr, self.attrname

   671 

   672     def getChildNodes(self):

   673         return self.expr,

   674 

   675     def __repr__(self):

   676         return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))

   677 

   678 class Global(Node):

   679     def __init__(self, names, lineno=None):

   680         self.names = names

   681         self.lineno = lineno

   682 

   683     def getChildren(self):

   684         return self.names,

   685 

   686     def getChildNodes(self):

   687         return ()

   688 

   689     def __repr__(self):

   690         return "Global(%s)" % (repr(self.names),)

   691 

   692 class If(Node):

   693     def __init__(self, tests, else_, lineno=None):

   694         self.tests = tests

   695         self.else_ = else_

   696         self.lineno = lineno

   697 

   698     def getChildren(self):

   699         children = []

   700         children.extend(flatten(self.tests))

   701         children.append(self.else_)

   702         return tuple(children)

   703 

   704     def getChildNodes(self):

   705         nodelist = []

   706         nodelist.extend(flatten_nodes(self.tests))

   707         if self.else_ is not None:

   708             nodelist.append(self.else_)

   709         return tuple(nodelist)

   710 

   711     def __repr__(self):

   712         return "If(%s, %s)" % (repr(self.tests), repr(self.else_))

   713 

   714 class IfExp(Node):

   715     def __init__(self, test, then, else_, lineno=None):

   716         self.test = test

   717         self.then = then

   718         self.else_ = else_

   719         self.lineno = lineno

   720 

   721     def getChildren(self):

   722         return self.test, self.then, self.else_

   723 

   724     def getChildNodes(self):

   725         return self.test, self.then, self.else_

   726 

   727     def __repr__(self):

   728         return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_))

   729 

   730 class Import(Node):

   731     def __init__(self, names, lineno=None):

   732         self.names = names

   733         self.lineno = lineno

   734 

   735     def getChildren(self):

   736         return self.names,

   737 

   738     def getChildNodes(self):

   739         return ()

   740 

   741     def __repr__(self):

   742         return "Import(%s)" % (repr(self.names),)

   743 

   744 class Invert(Node):

   745     def __init__(self, expr, lineno=None):

   746         self.expr = expr

   747         self.lineno = lineno

   748 

   749     def getChildren(self):

   750         return self.expr,

   751 

   752     def getChildNodes(self):

   753         return self.expr,

   754 

   755     def __repr__(self):

   756         return "Invert(%s)" % (repr(self.expr),)

   757 

   758 class Keyword(Node):

   759     def __init__(self, name, expr, lineno=None):

   760         self.name = name

   761         self.expr = expr

   762         self.lineno = lineno

   763 

   764     def getChildren(self):

   765         return self.name, self.expr

   766 

   767     def getChildNodes(self):

   768         return self.expr,

   769 

   770     def __repr__(self):

   771         return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))

   772 

   773 class Lambda(Node):

   774     def __init__(self, argnames, defaults, flags, code, lineno=None):

   775         self.argnames = argnames

   776         self.defaults = defaults

   777         self.flags = flags

   778         self.code = code

   779         self.lineno = lineno

   780         self.varargs = self.kwargs = None

   781         if flags & CO_VARARGS:

   782             self.varargs = 1

   783         if flags & CO_VARKEYWORDS:

   784             self.kwargs = 1

   785 

   786 

   787 

   788     def getChildren(self):

   789         children = []

   790         children.append(self.argnames)

   791         children.extend(flatten(self.defaults))

   792         children.append(self.flags)

   793         children.append(self.code)

   794         return tuple(children)

   795 

   796     def getChildNodes(self):

   797         nodelist = []

   798         nodelist.extend(flatten_nodes(self.defaults))

   799         nodelist.append(self.code)

   800         return tuple(nodelist)

   801 

   802     def __repr__(self):

   803         return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))

   804 

   805 class LeftShift(Node):

   806     def __init__(self, (left, right), lineno=None):

   807         self.left = left

   808         self.right = right

   809         self.lineno = lineno

   810 

   811     def getChildren(self):

   812         return self.left, self.right

   813 

   814     def getChildNodes(self):

   815         return self.left, self.right

   816 

   817     def __repr__(self):

   818         return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))

   819 

   820 class List(Node):

   821     def __init__(self, nodes, lineno=None):

   822         self.nodes = nodes

   823         self.lineno = lineno

   824 

   825     def getChildren(self):

   826         return tuple(flatten(self.nodes))

   827 

   828     def getChildNodes(self):

   829         nodelist = []

   830         nodelist.extend(flatten_nodes(self.nodes))

   831         return tuple(nodelist)

   832 

   833     def __repr__(self):

   834         return "List(%s)" % (repr(self.nodes),)

   835 

   836 class ListComp(Node):

   837     def __init__(self, expr, quals, lineno=None):

   838         self.expr = expr

   839         self.quals = quals

   840         self.lineno = lineno

   841 

   842     def getChildren(self):

   843         children = []

   844         children.append(self.expr)

   845         children.extend(flatten(self.quals))

   846         return tuple(children)

   847 

   848     def getChildNodes(self):

   849         nodelist = []

   850         nodelist.append(self.expr)

   851         nodelist.extend(flatten_nodes(self.quals))

   852         return tuple(nodelist)

   853 

   854     def __repr__(self):

   855         return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))

   856 

   857 class ListCompFor(Node):

   858     def __init__(self, assign, list, ifs, lineno=None):

   859         self.assign = assign

   860         self.list = list

   861         self.ifs = ifs

   862         self.lineno = lineno

   863 

   864     def getChildren(self):

   865         children = []

   866         children.append(self.assign)

   867         children.append(self.list)

   868         children.extend(flatten(self.ifs))

   869         return tuple(children)

   870 

   871     def getChildNodes(self):

   872         nodelist = []

   873         nodelist.append(self.assign)

   874         nodelist.append(self.list)

   875         nodelist.extend(flatten_nodes(self.ifs))

   876         return tuple(nodelist)

   877 

   878     def __repr__(self):

   879         return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))

   880 

   881 class ListCompIf(Node):

   882     def __init__(self, test, lineno=None):

   883         self.test = test

   884         self.lineno = lineno

   885 

   886     def getChildren(self):

   887         return self.test,

   888 

   889     def getChildNodes(self):

   890         return self.test,

   891 

   892     def __repr__(self):

   893         return "ListCompIf(%s)" % (repr(self.test),)

   894 

   895 class Mod(Node):

   896     def __init__(self, (left, right), lineno=None):

   897         self.left = left

   898         self.right = right

   899         self.lineno = lineno

   900 

   901     def getChildren(self):

   902         return self.left, self.right

   903 

   904     def getChildNodes(self):

   905         return self.left, self.right

   906 

   907     def __repr__(self):

   908         return "Mod((%s, %s))" % (repr(self.left), repr(self.right))

   909 

   910 class Module(Node):

   911     def __init__(self, doc, node, lineno=None):

   912         self.doc = doc

   913         self.node = node

   914         self.lineno = lineno

   915 

   916     def getChildren(self):

   917         return self.doc, self.node

   918 

   919     def getChildNodes(self):

   920         return self.node,

   921 

   922     def __repr__(self):

   923         return "Module(%s, %s)" % (repr(self.doc), repr(self.node))

   924 

   925 class Mul(Node):

   926     def __init__(self, (left, right), lineno=None):

   927         self.left = left

   928         self.right = right

   929         self.lineno = lineno

   930 

   931     def getChildren(self):

   932         return self.left, self.right

   933 

   934     def getChildNodes(self):

   935         return self.left, self.right

   936 

   937     def __repr__(self):

   938         return "Mul((%s, %s))" % (repr(self.left), repr(self.right))

   939 

   940 class Name(Node):

   941     def __init__(self, name, lineno=None):

   942         self.name = name

   943         self.lineno = lineno

   944 

   945     def getChildren(self):

   946         return self.name,

   947 

   948     def getChildNodes(self):

   949         return ()

   950 

   951     def __repr__(self):

   952         return "Name(%s)" % (repr(self.name),)

   953 

   954 class Not(Node):

   955     def __init__(self, expr, lineno=None):

   956         self.expr = expr

   957         self.lineno = lineno

   958 

   959     def getChildren(self):

   960         return self.expr,

   961 

   962     def getChildNodes(self):

   963         return self.expr,

   964 

   965     def __repr__(self):

   966         return "Not(%s)" % (repr(self.expr),)

   967 

   968 class Or(Node):

   969     def __init__(self, nodes, lineno=None):

   970         self.nodes = nodes

   971         self.lineno = lineno

   972 

   973     def getChildren(self):

   974         return tuple(flatten(self.nodes))

   975 

   976     def getChildNodes(self):

   977         nodelist = []

   978         nodelist.extend(flatten_nodes(self.nodes))

   979         return tuple(nodelist)

   980 

   981     def __repr__(self):

   982         return "Or(%s)" % (repr(self.nodes),)

   983 

   984 class Pass(Node):

   985     def __init__(self, lineno=None):

   986         self.lineno = lineno

   987 

   988     def getChildren(self):

   989         return ()

   990 

   991     def getChildNodes(self):

   992         return ()

   993 

   994     def __repr__(self):

   995         return "Pass()"

   996 

   997 class Power(Node):

   998     def __init__(self, (left, right), lineno=None):

   999         self.left = left

  1000         self.right = right

  1001         self.lineno = lineno

  1002 

  1003     def getChildren(self):

  1004         return self.left, self.right

  1005 

  1006     def getChildNodes(self):

  1007         return self.left, self.right

  1008 

  1009     def __repr__(self):

  1010         return "Power((%s, %s))" % (repr(self.left), repr(self.right))

  1011 

  1012 class Print(Node):

  1013     def __init__(self, nodes, dest, lineno=None):

  1014         self.nodes = nodes

  1015         self.dest = dest

  1016         self.lineno = lineno

  1017 

  1018     def getChildren(self):

  1019         children = []

  1020         children.extend(flatten(self.nodes))

  1021         children.append(self.dest)

  1022         return tuple(children)

  1023 

  1024     def getChildNodes(self):

  1025         nodelist = []

  1026         nodelist.extend(flatten_nodes(self.nodes))

  1027         if self.dest is not None:

  1028             nodelist.append(self.dest)

  1029         return tuple(nodelist)

  1030 

  1031     def __repr__(self):

  1032         return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))

  1033 

  1034 class Printnl(Node):

  1035     def __init__(self, nodes, dest, lineno=None):

  1036         self.nodes = nodes

  1037         self.dest = dest

  1038         self.lineno = lineno

  1039 

  1040     def getChildren(self):

  1041         children = []

  1042         children.extend(flatten(self.nodes))

  1043         children.append(self.dest)

  1044         return tuple(children)

  1045 

  1046     def getChildNodes(self):

  1047         nodelist = []

  1048         nodelist.extend(flatten_nodes(self.nodes))

  1049         if self.dest is not None:

  1050             nodelist.append(self.dest)

  1051         return tuple(nodelist)

  1052 

  1053     def __repr__(self):

  1054         return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))

  1055 

  1056 class Raise(Node):

  1057     def __init__(self, expr1, expr2, expr3, lineno=None):

  1058         self.expr1 = expr1

  1059         self.expr2 = expr2

  1060         self.expr3 = expr3

  1061         self.lineno = lineno

  1062 

  1063     def getChildren(self):

  1064         children = []

  1065         children.append(self.expr1)

  1066         children.append(self.expr2)

  1067         children.append(self.expr3)

  1068         return tuple(children)

  1069 

  1070     def getChildNodes(self):

  1071         nodelist = []

  1072         if self.expr1 is not None:

  1073             nodelist.append(self.expr1)

  1074         if self.expr2 is not None:

  1075             nodelist.append(self.expr2)

  1076         if self.expr3 is not None:

  1077             nodelist.append(self.expr3)

  1078         return tuple(nodelist)

  1079 

  1080     def __repr__(self):

  1081         return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))

  1082 

  1083 class Return(Node):

  1084     def __init__(self, value, lineno=None):

  1085         self.value = value

  1086         self.lineno = lineno

  1087 

  1088     def getChildren(self):

  1089         return self.value,

  1090 

  1091     def getChildNodes(self):

  1092         return self.value,

  1093 

  1094     def __repr__(self):

  1095         return "Return(%s)" % (repr(self.value),)

  1096 

  1097 class RightShift(Node):

  1098     def __init__(self, (left, right), lineno=None):

  1099         self.left = left

  1100         self.right = right

  1101         self.lineno = lineno

  1102 

  1103     def getChildren(self):

  1104         return self.left, self.right

  1105 

  1106     def getChildNodes(self):

  1107         return self.left, self.right

  1108 

  1109     def __repr__(self):

  1110         return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))

  1111 

  1112 class Slice(Node):

  1113     def __init__(self, expr, flags, lower, upper, lineno=None):

  1114         self.expr = expr

  1115         self.flags = flags

  1116         self.lower = lower

  1117         self.upper = upper

  1118         self.lineno = lineno

  1119 

  1120     def getChildren(self):

  1121         children = []

  1122         children.append(self.expr)

  1123         children.append(self.flags)

  1124         children.append(self.lower)

  1125         children.append(self.upper)

  1126         return tuple(children)

  1127 

  1128     def getChildNodes(self):

  1129         nodelist = []

  1130         nodelist.append(self.expr)

  1131         if self.lower is not None:

  1132             nodelist.append(self.lower)

  1133         if self.upper is not None:

  1134             nodelist.append(self.upper)

  1135         return tuple(nodelist)