"""Python abstract syntax node definitions

This file is automatically generated by Tools/compiler/astgen.py

"""

from compiler.consts import CO_VARARGS, CO_VARKEYWORDS

def flatten(seq):

    l = []

    for elt in seq:

        t = type(elt)

        if t is tuple or t is list:

            for elt2 in flatten(elt):

                l.append(elt2)

        else:

            l.append(elt)

    return l

def flatten_nodes(seq):

    return [n for n in flatten(seq) if isinstance(n, Node)]

nodes = {}

class Node:

    """Abstract base class for ast nodes."""

    def getChildren(self):

        pass # implemented by subclasses

    def __iter__(self):

        for n in self.getChildren():

            yield n

    def asList(self): # for backwards compatibility

        return self.getChildren()

    def getChildNodes(self):

        pass # implemented by subclasses

class EmptyNode(Node):

    pass

class Expression(Node):

    # Expression is an artificial node class to support "eval"

    nodes["expression"] = "Expression"

    def __init__(self, node):

        self.node = node

    def getChildren(self):

        return self.node,

    def getChildNodes(self):

        return self.node,

    def __repr__(self):

        return "Expression(%s)" % (repr(self.node))

class Add(Node):

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

        self.left = left

        self.right = right

        self.lineno = lineno

    def getChildren(self):

        return self.left, self.right

    def getChildNodes(self):

        return self.left, self.right

    def __repr__(self):

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

class And(Node):

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

        self.nodes = nodes

        self.lineno = lineno

    def getChildren(self):

        return tuple(flatten(self.nodes))

    def getChildNodes(self):

        nodelist = []

        nodelist.extend(flatten_nodes(self.nodes))

        return tuple(nodelist)

    def __repr__(self):

        return "And(%s)" % (repr(self.nodes),)

class AssAttr(Node):

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

        self.expr = expr

        self.attrname = attrname

        self.flags = flags

        self.lineno = lineno

    def getChildren(self):

        return self.expr, self.attrname, self.flags

    def getChildNodes(self):

        return self.expr,

    def __repr__(self):

        return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))

class AssList(Node):

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

        self.nodes = nodes

        self.lineno = lineno

    def getChildren(self):

        return tuple(flatten(self.nodes))

    def getChildNodes(self):

        nodelist = []

        nodelist.extend(flatten_nodes(self.nodes))

        return tuple(nodelist)

    def __repr__(self):

        return "AssList(%s)" % (repr(self.nodes),)

class AssName(Node):

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

        self.name = name

        self.flags = flags

        self.lineno = lineno

    def getChildren(self):

        return self.name, self.flags

    def getChildNodes(self):

        return ()

    def __repr__(self):

        return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))

class AssTuple(Node):

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

        self.nodes = nodes

        self.lineno = lineno

    def getChildren(self):

        return tuple(flatten(self.nodes))

    def getChildNodes(self):

        nodelist = []

        nodelist.extend(flatten_nodes(self.nodes))

        return tuple(nodelist)

    def __repr__(self):

        return "AssTuple(%s)" % (repr(self.nodes),)

class Assert(Node):

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

        self.test = test

        self.fail = fail

        self.lineno = lineno

    def getChildren(self):

        children = []

        children.append(self.test)

        children.append(self.fail)

        return tuple(children)

    def getChildNodes(self):

        nodelist = []

        nodelist.append(self.test)

        if self.fail is not None:

            nodelist.append(self.fail)

        return tuple(nodelist)

    def __repr__(self):

        return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))

class Assign(Node):

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

        self.nodes = nodes

        self.expr = expr

        self.lineno = lineno

    def getChildren(self):

        children = []

        children.extend(flatten(self.nodes))

        children.append(self.expr)

        return tuple(children)

    def getChildNodes(self):

        nodelist = []

        nodelist.extend(flatten_nodes(self.nodes))

        nodelist.append(self.expr)

        return tuple(nodelist)

    def __repr__(self):

        return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))

class AugAssign(Node):

    def __init__(self, node, op, expr, lineno=None):

        self.node = node

        self.op = op

        self.expr = expr

        self.lineno = lineno

    def getChildren(self):

        return self.node, self.op, self.expr

    def getChildNodes(self):

        return self.node, self.expr

    def __repr__(self):

        return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))

class Backquote(Node):

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

        self.expr = expr

        self.lineno = lineno

    def getChildren(self):

        return self.expr,

    def getChildNodes(self):

        return self.expr,

    def __repr__(self):

        return "Backquote(%s)" % (repr(self.expr),)

class Bitand(Node):

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

        self.nodes = nodes

        self.lineno = lineno

    def getChildren(self):

        return tuple(flatten(self.nodes))

    def getChildNodes(self):

        nodelist = []

        nodelist.extend(flatten_nodes(self.nodes))

        return tuple(nodelist)

    def __repr__(self):

        return "Bitand(%s)" % (repr(self.nodes),)

class Bitor(Node):

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

        self.nodes = nodes

        self.lineno = lineno

    def getChildren(self):

        return tuple(flatten(self.nodes))

    def getChildNodes(self):

        nodelist = []

        nodelist.extend(flatten_nodes(self.nodes))

        return tuple(nodelist)

    def __repr__(self):

        return "Bitor(%s)" % (repr(self.nodes),)

class Bitxor(Node):

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

        self.nodes = nodes

        self.lineno = lineno

    def getChildren(self):

        return tuple(flatten(self.nodes))

    def getChildNodes(self):

        nodelist = []

        nodelist.extend(flatten_nodes(self.nodes))

        return tuple(nodelist)

    def __repr__(self):

        return "Bitxor(%s)" % (repr(self.nodes),)

class Break(Node):

    def __init__(self, lineno=None):

        self.lineno = lineno

    def getChildren(self):

        return ()

    def getChildNodes(self):

        return ()

    def __repr__(self):

        return "Break()"

class CallFunc(Node):

    def __init__(self, node, args, star_args = None, dstar_args = None, lineno=None):

        self.node = node

        self.args = args

        self.star_args = star_args

        self.dstar_args = dstar_args

        self.lineno = lineno

    def getChildren(self):

        children = []

        children.append(self.node)

        children.extend(flatten(self.args))

        children.append(self.star_args)

        children.append(self.dstar_args)

        return tuple(children)

    def getChildNodes(self):

        nodelist = []

        nodelist.append(self.node)

        nodelist.extend(flatten_nodes(self.args))

        if self.star_args is not None:

            nodelist.append(self.star_args)

        if self.dstar_args is not None:

            nodelist.append(self.dstar_args)

        return tuple(nodelist)

    def __repr__(self):

        return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))

class Class(Node):

    def __init__(self, name, bases, doc, code, decorators = None, lineno=None):

        self.name = name

        self.bases = bases

        self.doc = doc

        self.code = code

        self.decorators = decorators

        self.lineno = lineno

    def getChildren(self):

        children = []

        children.append(self.name)

        children.extend(flatten(self.bases))

        children.append(self.doc)

        children.append(self.code)

        children.append(self.decorators)

        return tuple(children)

    def getChildNodes(self):

        nodelist = []

        nodelist.extend(flatten_nodes(self.bases))

        nodelist.append(self.code)

        if self.decorators is not None:

            nodelist.append(self.decorators)

        return tuple(nodelist)

    def __repr__(self):

        return "Class(%s, %s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code), repr(self.decorators))

class Compare(Node):

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

        self.expr = expr

        self.ops = ops

        self.lineno = lineno

    def getChildren(self):

        children = []

        children.append(self.expr)

        children.extend(flatten(self.ops))

        return tuple(children)

    def getChildNodes(self):

        nodelist = []

        nodelist.append(self.expr)

        nodelist.extend(flatten_nodes(self.ops))

        return tuple(nodelist)

    def __repr__(self):

        return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))

class Const(Node):

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

        self.value = value

        self.lineno = lineno

    def getChildren(self):

        return self.value,

    def getChildNodes(self):

        return ()

    def __repr__(self):

        return "Const(%s)" % (repr(self.value),)

class Continue(Node):

    def __init__(self, lineno=None):

        self.lineno = lineno

    def getChildren(self):

        return ()

    def getChildNodes(self):

        return ()

    def __repr__(self):

        return "Continue()"

class Decorators(Node):

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

        self.nodes = nodes

        self.lineno = lineno

    def getChildren(self):

        return tuple(flatten(self.nodes))

    def getChildNodes(self):

        nodelist = []

        nodelist.extend(flatten_nodes(self.nodes))

        return tuple(nodelist)

    def __repr__(self):

        return "Decorators(%s)" % (repr(self.nodes),)

class Dict(Node):

    def __init__(self, items, lineno=None):

        self.items = items

        self.lineno = lineno

    def getChildren(self):

        return tuple(flatten(self.items))

    def getChildNodes(self):

        nodelist = []

        nodelist.extend(flatten_nodes(self.items))

        return tuple(nodelist)

    def __repr__(self):

        return "Dict(%s)" % (repr(self.items),)

class Discard(Node):

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

        self.expr = expr

        self.lineno = lineno

    def getChildren(self):

        return self.expr,

    def getChildNodes(self):

        return self.expr,

    def __repr__(self):

        return "Discard(%s)" % (repr(self.expr),)

class Div(Node):

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

        self.left = left

        self.right = right

        self.lineno = lineno

    def getChildren(self):

        return self.left, self.right

    def getChildNodes(self):

        return self.left, self.right

    def __repr__(self):

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

class Ellipsis(Node):

    def __init__(self, lineno=None):

        self.lineno = lineno

    def getChildren(self):

        return ()

    def getChildNodes(self):

        return ()

    def __repr__(self):

        return "Ellipsis()"

class Exec(Node):

    def __init__(self, expr, locals, globals, lineno=None):

        self.expr = expr

        self.locals = locals

        self.globals = globals

        self.lineno = lineno

    def getChildren(self):

        children = []

        children.append(self.expr)

        children.append(self.locals)

        children.append(self.globals)

        return tuple(children)

    def getChildNodes(self):

        nodelist = []

        nodelist.append(self.expr)

        if self.locals is not None:

            nodelist.append(self.locals)

        if self.globals is not None:

            nodelist.append(self.globals)

        return tuple(nodelist)

    def __repr__(self):

        return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))

class FloorDiv(Node):

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

        self.left = left

        self.right = right

        self.lineno = lineno

    def getChildren(self):

        return self.left, self.right

    def getChildNodes(self):

        return self.left, self.right

    def __repr__(self):

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

class For(Node):

    def __init__(self, assign, list, body, else_, lineno=None):

        self.assign = assign

        self.list = list

        self.body = body

        self.else_ = else_

        self.lineno = lineno

    def getChildren(self):

        children = []

        children.append(self.assign)

        children.append(self.list)

        children.append(self.body)

        children.append(self.else_)

        return tuple(children)

    def getChildNodes(self):

        nodelist = []

        nodelist.append(self.assign)

        nodelist.append(self.list)

        nodelist.append(self.body)

        if self.else_ is not None:

            nodelist.append(self.else_)

        return tuple(nodelist)

    def __repr__(self):

        return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))