"""Python abstract syntax node definitions
This file is automatically generated by Tools/compiler/astgen.py
from consts
import CO_VARARGS
, CO_VARKEYWORDS
if t
is tuple or t
is list:
for elt2
in flatten(elt
):
return [n
for n
in flatten(list) if isinstance(n
, Node
)]
"""Abstract base class for ast nodes."""
pass # implemented by subclasses
for n
in self
.getChildren():
def asList(self
): # for backwards compatibility
return self
.getChildren()
pass # implemented by subclasses
# Expression is an artificial node class to support "eval"
nodes
["expression"] = "Expression"
def __init__(self
, node
):
return "Expression(%s)" % (repr(self
.node
))
def __init__(self
, (left
, right
), lineno
=None):
return self
.left
, self
.right
return self
.left
, self
.right
return "Add((%s, %s))" % (repr(self
.left
), repr(self
.right
))
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "And(%s)" % (repr(self
.nodes
),)
def __init__(self
, expr
, attrname
, flags
, lineno
=None):
return self
.expr
, self
.attrname
, self
.flags
return "AssAttr(%s, %s, %s)" % (repr(self
.expr
), repr(self
.attrname
), repr(self
.flags
))
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "AssList(%s)" % (repr(self
.nodes
),)
def __init__(self
, name
, flags
, lineno
=None):
return self
.name
, self
.flags
return "AssName(%s, %s)" % (repr(self
.name
), repr(self
.flags
))
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "AssTuple(%s)" % (repr(self
.nodes
),)
def __init__(self
, test
, fail
, lineno
=None):
children
.append(self
.test
)
children
.append(self
.fail
)
nodelist
.append(self
.test
)
if self
.fail
is not None:
nodelist
.append(self
.fail
)
return "Assert(%s, %s)" % (repr(self
.test
), repr(self
.fail
))
def __init__(self
, nodes
, expr
, lineno
=None):
children
.extend(flatten(self
.nodes
))
children
.append(self
.expr
)
nodelist
.extend(flatten_nodes(self
.nodes
))
nodelist
.append(self
.expr
)
return "Assign(%s, %s)" % (repr(self
.nodes
), repr(self
.expr
))
def __init__(self
, node
, op
, expr
, lineno
=None):
return self
.node
, self
.op
, self
.expr
return self
.node
, self
.expr
return "AugAssign(%s, %s, %s)" % (repr(self
.node
), repr(self
.op
), repr(self
.expr
))
def __init__(self
, expr
, lineno
=None):
return "Backquote(%s)" % (repr(self
.expr
),)
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "Bitand(%s)" % (repr(self
.nodes
),)
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "Bitor(%s)" % (repr(self
.nodes
),)
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "Bitxor(%s)" % (repr(self
.nodes
),)
def __init__(self
, lineno
=None):
def __init__(self
, node
, args
, star_args
= None, dstar_args
= None, lineno
=None):
self
.star_args
= star_args
self
.dstar_args
= dstar_args
children
.append(self
.node
)
children
.extend(flatten(self
.args
))
children
.append(self
.star_args
)
children
.append(self
.dstar_args
)
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 "CallFunc(%s, %s, %s, %s)" % (repr(self
.node
), repr(self
.args
), repr(self
.star_args
), repr(self
.dstar_args
))
def __init__(self
, name
, bases
, doc
, code
, lineno
=None):
children
.append(self
.name
)
children
.extend(flatten(self
.bases
))
children
.append(self
.doc
)
children
.append(self
.code
)
nodelist
.extend(flatten_nodes(self
.bases
))
nodelist
.append(self
.code
)
return "Class(%s, %s, %s, %s)" % (repr(self
.name
), repr(self
.bases
), repr(self
.doc
), repr(self
.code
))
def __init__(self
, expr
, ops
, lineno
=None):
children
.append(self
.expr
)
children
.extend(flatten(self
.ops
))
nodelist
.append(self
.expr
)
nodelist
.extend(flatten_nodes(self
.ops
))
return "Compare(%s, %s)" % (repr(self
.expr
), repr(self
.ops
))
def __init__(self
, value
, lineno
=None):
return "Const(%s)" % (repr(self
.value
),)
def __init__(self
, lineno
=None):
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "Decorators(%s)" % (repr(self
.nodes
),)
def __init__(self
, items
, lineno
=None):
return tuple(flatten(self
.items
))
nodelist
.extend(flatten_nodes(self
.items
))
return "Dict(%s)" % (repr(self
.items
),)
def __init__(self
, expr
, lineno
=None):
return "Discard(%s)" % (repr(self
.expr
),)
def __init__(self
, (left
, right
), lineno
=None):
return self
.left
, self
.right
return self
.left
, self
.right
return "Div((%s, %s))" % (repr(self
.left
), repr(self
.right
))
def __init__(self
, lineno
=None):
def __init__(self
, expr
, locals, globals, lineno
=None):
children
.append(self
.expr
)
children
.append(self
.locals)
children
.append(self
.globals)
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 "Exec(%s, %s, %s)" % (repr(self
.expr
), repr(self
.locals), repr(self
.globals))
def __init__(self
, (left
, right
), lineno
=None):
return self
.left
, self
.right
return self
.left
, self
.right
return "FloorDiv((%s, %s))" % (repr(self
.left
), repr(self
.right
))
def __init__(self
, assign
, list, body
, else_
, lineno
=None):
children
.append(self
.assign
)
children
.append(self
.list)
children
.append(self
.body
)
children
.append(self
.else_
)
nodelist
.append(self
.assign
)
nodelist
.append(self
.list)
nodelist
.append(self
.body
)
if self
.else_
is not None:
nodelist
.append(self
.else_
)
return "For(%s, %s, %s, %s)" % (repr(self
.assign
), repr(self
.list), repr(self
.body
), repr(self
.else_
))
def __init__(self
, modname
, names
, lineno
=None):
return self
.modname
, self
.names
return "From(%s, %s)" % (repr(self
.modname
), repr(self
.names
))
def __init__(self
, decorators
, name
, argnames
, defaults
, flags
, doc
, code
, lineno
=None):
self
.decorators
= decorators
self
.varargs
= self
.kwargs
= None
if flags
& CO_VARKEYWORDS
:
children
.append(self
.decorators
)
children
.append(self
.name
)
children
.append(self
.argnames
)
children
.extend(flatten(self
.defaults
))
children
.append(self
.flags
)
children
.append(self
.doc
)
children
.append(self
.code
)
if self
.decorators
is not None:
nodelist
.append(self
.decorators
)
nodelist
.extend(flatten_nodes(self
.defaults
))
nodelist
.append(self
.code
)
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
))
def __init__(self
, code
, lineno
=None):
self
.argnames
= ['[outmost-iterable]']
self
.varargs
= self
.kwargs
= None
return "GenExpr(%s)" % (repr(self
.code
),)
def __init__(self
, assign
, iter, ifs
, lineno
=None):
children
.append(self
.assign
)
children
.append(self
.iter)
children
.extend(flatten(self
.ifs
))
nodelist
.append(self
.assign
)
nodelist
.append(self
.iter)
nodelist
.extend(flatten_nodes(self
.ifs
))
return "GenExprFor(%s, %s, %s)" % (repr(self
.assign
), repr(self
.iter), repr(self
.ifs
))
def __init__(self
, test
, lineno
=None):
return "GenExprIf(%s)" % (repr(self
.test
),)
class GenExprInner(Node
):
def __init__(self
, expr
, quals
, lineno
=None):
children
.append(self
.expr
)
children
.extend(flatten(self
.quals
))
nodelist
.append(self
.expr
)
nodelist
.extend(flatten_nodes(self
.quals
))
return "GenExprInner(%s, %s)" % (repr(self
.expr
), repr(self
.quals
))
def __init__(self
, expr
, attrname
, lineno
=None):
return self
.expr
, self
.attrname
return "Getattr(%s, %s)" % (repr(self
.expr
), repr(self
.attrname
))
def __init__(self
, names
, lineno
=None):
return "Global(%s)" % (repr(self
.names
),)
def __init__(self
, tests
, else_
, lineno
=None):
children
.extend(flatten(self
.tests
))
children
.append(self
.else_
)
nodelist
.extend(flatten_nodes(self
.tests
))
if self
.else_
is not None:
nodelist
.append(self
.else_
)
return "If(%s, %s)" % (repr(self
.tests
), repr(self
.else_
))
def __init__(self
, names
, lineno
=None):
return "Import(%s)" % (repr(self
.names
),)
def __init__(self
, expr
, lineno
=None):
return "Invert(%s)" % (repr(self
.expr
),)
def __init__(self
, name
, expr
, lineno
=None):
return self
.name
, self
.expr
return "Keyword(%s, %s)" % (repr(self
.name
), repr(self
.expr
))
def __init__(self
, argnames
, defaults
, flags
, code
, lineno
=None):
self
.varargs
= self
.kwargs
= None
if flags
& CO_VARKEYWORDS
:
children
.append(self
.argnames
)
children
.extend(flatten(self
.defaults
))
children
.append(self
.flags
)
children
.append(self
.code
)
nodelist
.extend(flatten_nodes(self
.defaults
))
nodelist
.append(self
.code
)
return "Lambda(%s, %s, %s, %s)" % (repr(self
.argnames
), repr(self
.defaults
), repr(self
.flags
), repr(self
.code
))
def __init__(self
, (left
, right
), lineno
=None):
return self
.left
, self
.right
return self
.left
, self
.right
return "LeftShift((%s, %s))" % (repr(self
.left
), repr(self
.right
))
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "List(%s)" % (repr(self
.nodes
),)
def __init__(self
, expr
, quals
, lineno
=None):
children
.append(self
.expr
)
children
.extend(flatten(self
.quals
))
nodelist
.append(self
.expr
)
nodelist
.extend(flatten_nodes(self
.quals
))
return "ListComp(%s, %s)" % (repr(self
.expr
), repr(self
.quals
))
def __init__(self
, assign
, list, ifs
, lineno
=None):
children
.append(self
.assign
)
children
.append(self
.list)
children
.extend(flatten(self
.ifs
))
nodelist
.append(self
.assign
)
nodelist
.append(self
.list)
nodelist
.extend(flatten_nodes(self
.ifs
))
return "ListCompFor(%s, %s, %s)" % (repr(self
.assign
), repr(self
.list), repr(self
.ifs
))
def __init__(self
, test
, lineno
=None):
return "ListCompIf(%s)" % (repr(self
.test
),)
def __init__(self
, (left
, right
), lineno
=None):
return self
.left
, self
.right
return self
.left
, self
.right
return "Mod((%s, %s))" % (repr(self
.left
), repr(self
.right
))
def __init__(self
, doc
, node
, lineno
=None):
return self
.doc
, self
.node
return "Module(%s, %s)" % (repr(self
.doc
), repr(self
.node
))
def __init__(self
, (left
, right
), lineno
=None):
return self
.left
, self
.right
return self
.left
, self
.right
return "Mul((%s, %s))" % (repr(self
.left
), repr(self
.right
))
def __init__(self
, name
, lineno
=None):
return "Name(%s)" % (repr(self
.name
),)
def __init__(self
, expr
, lineno
=None):
return "Not(%s)" % (repr(self
.expr
),)
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "Or(%s)" % (repr(self
.nodes
),)
def __init__(self
, lineno
=None):
def __init__(self
, (left
, right
), lineno
=None):
return self
.left
, self
.right
return self
.left
, self
.right
return "Power((%s, %s))" % (repr(self
.left
), repr(self
.right
))
def __init__(self
, nodes
, dest
, lineno
=None):
children
.extend(flatten(self
.nodes
))
children
.append(self
.dest
)
nodelist
.extend(flatten_nodes(self
.nodes
))
if self
.dest
is not None:
nodelist
.append(self
.dest
)
return "Print(%s, %s)" % (repr(self
.nodes
), repr(self
.dest
))
def __init__(self
, nodes
, dest
, lineno
=None):
children
.extend(flatten(self
.nodes
))
children
.append(self
.dest
)
nodelist
.extend(flatten_nodes(self
.nodes
))
if self
.dest
is not None:
nodelist
.append(self
.dest
)
return "Printnl(%s, %s)" % (repr(self
.nodes
), repr(self
.dest
))
def __init__(self
, expr1
, expr2
, expr3
, lineno
=None):
children
.append(self
.expr1
)
children
.append(self
.expr2
)
children
.append(self
.expr3
)
if self
.expr1
is not None:
nodelist
.append(self
.expr1
)
if self
.expr2
is not None:
nodelist
.append(self
.expr2
)
if self
.expr3
is not None:
nodelist
.append(self
.expr3
)
return "Raise(%s, %s, %s)" % (repr(self
.expr1
), repr(self
.expr2
), repr(self
.expr3
))
def __init__(self
, value
, lineno
=None):
return "Return(%s)" % (repr(self
.value
),)
def __init__(self
, (left
, right
), lineno
=None):
return self
.left
, self
.right
return self
.left
, self
.right
return "RightShift((%s, %s))" % (repr(self
.left
), repr(self
.right
))
def __init__(self
, expr
, flags
, lower
, upper
, lineno
=None):
children
.append(self
.expr
)
children
.append(self
.flags
)
children
.append(self
.lower
)
children
.append(self
.upper
)
nodelist
.append(self
.expr
)
if self
.lower
is not None:
nodelist
.append(self
.lower
)
if self
.upper
is not None:
nodelist
.append(self
.upper
)
return "Slice(%s, %s, %s, %s)" % (repr(self
.expr
), repr(self
.flags
), repr(self
.lower
), repr(self
.upper
))
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "Sliceobj(%s)" % (repr(self
.nodes
),)
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "Stmt(%s)" % (repr(self
.nodes
),)
def __init__(self
, (left
, right
), lineno
=None):
return self
.left
, self
.right
return self
.left
, self
.right
return "Sub((%s, %s))" % (repr(self
.left
), repr(self
.right
))
def __init__(self
, expr
, flags
, subs
, lineno
=None):
children
.append(self
.expr
)
children
.append(self
.flags
)
children
.extend(flatten(self
.subs
))
nodelist
.append(self
.expr
)
nodelist
.extend(flatten_nodes(self
.subs
))
return "Subscript(%s, %s, %s)" % (repr(self
.expr
), repr(self
.flags
), repr(self
.subs
))
def __init__(self
, body
, handlers
, else_
, lineno
=None):
children
.append(self
.body
)
children
.extend(flatten(self
.handlers
))
children
.append(self
.else_
)
nodelist
.append(self
.body
)
nodelist
.extend(flatten_nodes(self
.handlers
))
if self
.else_
is not None:
nodelist
.append(self
.else_
)
return "TryExcept(%s, %s, %s)" % (repr(self
.body
), repr(self
.handlers
), repr(self
.else_
))
def __init__(self
, body
, final
, lineno
=None):
return self
.body
, self
.final
return self
.body
, self
.final
return "TryFinally(%s, %s)" % (repr(self
.body
), repr(self
.final
))
def __init__(self
, nodes
, lineno
=None):
return tuple(flatten(self
.nodes
))
nodelist
.extend(flatten_nodes(self
.nodes
))
return "Tuple(%s)" % (repr(self
.nodes
),)
def __init__(self
, expr
, lineno
=None):
return "UnaryAdd(%s)" % (repr(self
.expr
),)
def __init__(self
, expr
, lineno
=None):
return "UnarySub(%s)" % (repr(self
.expr
),)
def __init__(self
, test
, body
, else_
, lineno
=None):
children
.append(self
.test
)
children
.append(self
.body
)
children
.append(self
.else_
)
nodelist
.append(self
.test
)
nodelist
.append(self
.body
)
if self
.else_
is not None:
nodelist
.append(self
.else_
)
return "While(%s, %s, %s)" % (repr(self
.test
), repr(self
.body
), repr(self
.else_
))
def __init__(self
, value
, lineno
=None):
return "Yield(%s)" % (repr(self
.value
),)
for name
, obj
in globals().items():
if isinstance(obj
, type) and issubclass(obj
, Node
):
nodes
[name
.lower()] = obj