| """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, leftright, lineno=None): |
| self.left = leftright[0] |
| self.right = leftright[1] |
| 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, leftright, lineno=None): |
| self.left = leftright[0] |
| self.right = leftright[1] |
| 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, leftright, lineno=None): |
| self.left = leftright[0] |
| self.right = leftright[1] |
| 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_)) |
| |
| class From(Node): |
| def __init__(self, modname, names, level, lineno=None): |
| self.modname = modname |
| self.names = names |
| self.level = level |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.modname, self.names, self.level |
| |
| def getChildNodes(self): |
| return () |
| |
| def __repr__(self): |
| return "From(%s, %s, %s)" % (repr(self.modname), repr(self.names), repr(self.level)) |
| |
| class Function(Node): |
| def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None): |
| self.decorators = decorators |
| self.name = name |
| self.argnames = argnames |
| self.defaults = defaults |
| self.flags = flags |
| self.doc = doc |
| self.code = code |
| self.lineno = lineno |
| self.varargs = self.kwargs = None |
| if flags & CO_VARARGS: |
| self.varargs = 1 |
| if flags & CO_VARKEYWORDS: |
| self.kwargs = 1 |
| |
| |
| def getChildren(self): |
| children = [] |
| 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) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| if self.decorators is not None: |
| nodelist.append(self.decorators) |
| nodelist.extend(flatten_nodes(self.defaults)) |
| nodelist.append(self.code) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| 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)) |
| |
| class GenExpr(Node): |
| def __init__(self, code, lineno=None): |
| self.code = code |
| self.lineno = lineno |
| self.argnames = ['.0'] |
| self.varargs = self.kwargs = None |
| |
| |
| def getChildren(self): |
| return self.code, |
| |
| def getChildNodes(self): |
| return self.code, |
| |
| def __repr__(self): |
| return "GenExpr(%s)" % (repr(self.code),) |
| |
| class GenExprFor(Node): |
| def __init__(self, assign, iter, ifs, lineno=None): |
| self.assign = assign |
| self.iter = iter |
| self.ifs = ifs |
| self.lineno = lineno |
| self.is_outmost = False |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.assign) |
| children.append(self.iter) |
| children.extend(flatten(self.ifs)) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.append(self.assign) |
| nodelist.append(self.iter) |
| nodelist.extend(flatten_nodes(self.ifs)) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs)) |
| |
| class GenExprIf(Node): |
| def __init__(self, test, lineno=None): |
| self.test = test |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.test, |
| |
| def getChildNodes(self): |
| return self.test, |
| |
| def __repr__(self): |
| return "GenExprIf(%s)" % (repr(self.test),) |
| |
| class GenExprInner(Node): |
| def __init__(self, expr, quals, lineno=None): |
| self.expr = expr |
| self.quals = quals |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.expr) |
| children.extend(flatten(self.quals)) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.append(self.expr) |
| nodelist.extend(flatten_nodes(self.quals)) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals)) |
| |
| class Getattr(Node): |
| def __init__(self, expr, attrname, lineno=None): |
| self.expr = expr |
| self.attrname = attrname |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.expr, self.attrname |
| |
| def getChildNodes(self): |
| return self.expr, |
| |
| def __repr__(self): |
| return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname)) |
| |
| class Global(Node): |
| def __init__(self, names, lineno=None): |
| self.names = names |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.names, |
| |
| def getChildNodes(self): |
| return () |
| |
| def __repr__(self): |
| return "Global(%s)" % (repr(self.names),) |
| |
| class If(Node): |
| def __init__(self, tests, else_, lineno=None): |
| self.tests = tests |
| self.else_ = else_ |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.extend(flatten(self.tests)) |
| children.append(self.else_) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.extend(flatten_nodes(self.tests)) |
| if self.else_ is not None: |
| nodelist.append(self.else_) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "If(%s, %s)" % (repr(self.tests), repr(self.else_)) |
| |
| class IfExp(Node): |
| def __init__(self, test, then, else_, lineno=None): |
| self.test = test |
| self.then = then |
| self.else_ = else_ |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.test, self.then, self.else_ |
| |
| def getChildNodes(self): |
| return self.test, self.then, self.else_ |
| |
| def __repr__(self): |
| return "IfExp(%s, %s, %s)" % (repr(self.test), repr(self.then), repr(self.else_)) |
| |
| class Import(Node): |
| def __init__(self, names, lineno=None): |
| self.names = names |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.names, |
| |
| def getChildNodes(self): |
| return () |
| |
| def __repr__(self): |
| return "Import(%s)" % (repr(self.names),) |
| |
| class Invert(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 "Invert(%s)" % (repr(self.expr),) |
| |
| class Keyword(Node): |
| def __init__(self, name, expr, lineno=None): |
| self.name = name |
| self.expr = expr |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.name, self.expr |
| |
| def getChildNodes(self): |
| return self.expr, |
| |
| def __repr__(self): |
| return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr)) |
| |
| class Lambda(Node): |
| def __init__(self, argnames, defaults, flags, code, lineno=None): |
| self.argnames = argnames |
| self.defaults = defaults |
| self.flags = flags |
| self.code = code |
| self.lineno = lineno |
| self.varargs = self.kwargs = None |
| if flags & CO_VARARGS: |
| self.varargs = 1 |
| if flags & CO_VARKEYWORDS: |
| self.kwargs = 1 |
| |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.argnames) |
| children.extend(flatten(self.defaults)) |
| children.append(self.flags) |
| children.append(self.code) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.extend(flatten_nodes(self.defaults)) |
| nodelist.append(self.code) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code)) |
| |
| class LeftShift(Node): |
| def __init__(self, leftright, lineno=None): |
| self.left = leftright[0] |
| self.right = leftright[1] |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.left, self.right |
| |
| def getChildNodes(self): |
| return self.left, self.right |
| |
| def __repr__(self): |
| return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right)) |
| |
| class List(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 "List(%s)" % (repr(self.nodes),) |
| |
| class ListComp(Node): |
| def __init__(self, expr, quals, lineno=None): |
| self.expr = expr |
| self.quals = quals |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.expr) |
| children.extend(flatten(self.quals)) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.append(self.expr) |
| nodelist.extend(flatten_nodes(self.quals)) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals)) |
| |
| class ListCompFor(Node): |
| def __init__(self, assign, list, ifs, lineno=None): |
| self.assign = assign |
| self.list = list |
| self.ifs = ifs |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.assign) |
| children.append(self.list) |
| children.extend(flatten(self.ifs)) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.append(self.assign) |
| nodelist.append(self.list) |
| nodelist.extend(flatten_nodes(self.ifs)) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs)) |
| |
| class ListCompIf(Node): |
| def __init__(self, test, lineno=None): |
| self.test = test |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.test, |
| |
| def getChildNodes(self): |
| return self.test, |
| |
| def __repr__(self): |
| return "ListCompIf(%s)" % (repr(self.test),) |
| |
| class SetComp(Node): |
| def __init__(self, expr, quals, lineno=None): |
| self.expr = expr |
| self.quals = quals |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.expr) |
| children.extend(flatten(self.quals)) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.append(self.expr) |
| nodelist.extend(flatten_nodes(self.quals)) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "SetComp(%s, %s)" % (repr(self.expr), repr(self.quals)) |
| |
| class DictComp(Node): |
| def __init__(self, key, value, quals, lineno=None): |
| self.key = key |
| self.value = value |
| self.quals = quals |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.key) |
| children.append(self.value) |
| children.extend(flatten(self.quals)) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.append(self.key) |
| nodelist.append(self.value) |
| nodelist.extend(flatten_nodes(self.quals)) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "DictComp(%s, %s, %s)" % (repr(self.key), repr(self.value), repr(self.quals)) |
| |
| class Mod(Node): |
| def __init__(self, leftright, lineno=None): |
| self.left = leftright[0] |
| self.right = leftright[1] |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.left, self.right |
| |
| def getChildNodes(self): |
| return self.left, self.right |
| |
| def __repr__(self): |
| return "Mod((%s, %s))" % (repr(self.left), repr(self.right)) |
| |
| class Module(Node): |
| def __init__(self, doc, node, lineno=None): |
| self.doc = doc |
| self.node = node |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.doc, self.node |
| |
| def getChildNodes(self): |
| return self.node, |
| |
| def __repr__(self): |
| return "Module(%s, %s)" % (repr(self.doc), repr(self.node)) |
| |
| class Mul(Node): |
| def __init__(self, leftright, lineno=None): |
| self.left = leftright[0] |
| self.right = leftright[1] |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.left, self.right |
| |
| def getChildNodes(self): |
| return self.left, self.right |
| |
| def __repr__(self): |
| return "Mul((%s, %s))" % (repr(self.left), repr(self.right)) |
| |
| class Name(Node): |
| def __init__(self, name, lineno=None): |
| self.name = name |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.name, |
| |
| def getChildNodes(self): |
| return () |
| |
| def __repr__(self): |
| return "Name(%s)" % (repr(self.name),) |
| |
| class Not(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 "Not(%s)" % (repr(self.expr),) |
| |
| class Or(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 "Or(%s)" % (repr(self.nodes),) |
| |
| class Pass(Node): |
| def __init__(self, lineno=None): |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return () |
| |
| def getChildNodes(self): |
| return () |
| |
| def __repr__(self): |
| return "Pass()" |
| |
| class Power(Node): |
| def __init__(self, leftright, lineno=None): |
| self.left = leftright[0] |
| self.right = leftright[1] |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.left, self.right |
| |
| def getChildNodes(self): |
| return self.left, self.right |
| |
| def __repr__(self): |
| return "Power((%s, %s))" % (repr(self.left), repr(self.right)) |
| |
| class Print(Node): |
| def __init__(self, nodes, dest, lineno=None): |
| self.nodes = nodes |
| self.dest = dest |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.extend(flatten(self.nodes)) |
| children.append(self.dest) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.extend(flatten_nodes(self.nodes)) |
| if self.dest is not None: |
| nodelist.append(self.dest) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest)) |
| |
| class Printnl(Node): |
| def __init__(self, nodes, dest, lineno=None): |
| self.nodes = nodes |
| self.dest = dest |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.extend(flatten(self.nodes)) |
| children.append(self.dest) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.extend(flatten_nodes(self.nodes)) |
| if self.dest is not None: |
| nodelist.append(self.dest) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest)) |
| |
| class Raise(Node): |
| def __init__(self, expr1, expr2, expr3, lineno=None): |
| self.expr1 = expr1 |
| self.expr2 = expr2 |
| self.expr3 = expr3 |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.expr1) |
| children.append(self.expr2) |
| children.append(self.expr3) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| 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 tuple(nodelist) |
| |
| def __repr__(self): |
| return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3)) |
| |
| class Return(Node): |
| def __init__(self, value, lineno=None): |
| self.value = value |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.value, |
| |
| def getChildNodes(self): |
| return self.value, |
| |
| def __repr__(self): |
| return "Return(%s)" % (repr(self.value),) |
| |
| class RightShift(Node): |
| def __init__(self, leftright, lineno=None): |
| self.left = leftright[0] |
| self.right = leftright[1] |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.left, self.right |
| |
| def getChildNodes(self): |
| return self.left, self.right |
| |
| def __repr__(self): |
| return "RightShift((%s, %s))" % (repr(self.left), repr(self.right)) |
| |
| class Set(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 "Set(%s)" % (repr(self.nodes),) |
| |
| class Slice(Node): |
| def __init__(self, expr, flags, lower, upper, lineno=None): |
| self.expr = expr |
| self.flags = flags |
| self.lower = lower |
| self.upper = upper |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.expr) |
| children.append(self.flags) |
| children.append(self.lower) |
| children.append(self.upper) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| 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 tuple(nodelist) |
| |
| def __repr__(self): |
| return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper)) |
| |
| class Sliceobj(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 "Sliceobj(%s)" % (repr(self.nodes),) |
| |
| class Stmt(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 "Stmt(%s)" % (repr(self.nodes),) |
| |
| class Sub(Node): |
| def __init__(self, leftright, lineno=None): |
| self.left = leftright[0] |
| self.right = leftright[1] |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.left, self.right |
| |
| def getChildNodes(self): |
| return self.left, self.right |
| |
| def __repr__(self): |
| return "Sub((%s, %s))" % (repr(self.left), repr(self.right)) |
| |
| class Subscript(Node): |
| def __init__(self, expr, flags, subs, lineno=None): |
| self.expr = expr |
| self.flags = flags |
| self.subs = subs |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.expr) |
| children.append(self.flags) |
| children.extend(flatten(self.subs)) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.append(self.expr) |
| nodelist.extend(flatten_nodes(self.subs)) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs)) |
| |
| class TryExcept(Node): |
| def __init__(self, body, handlers, else_, lineno=None): |
| self.body = body |
| self.handlers = handlers |
| self.else_ = else_ |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.body) |
| children.extend(flatten(self.handlers)) |
| children.append(self.else_) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.append(self.body) |
| nodelist.extend(flatten_nodes(self.handlers)) |
| if self.else_ is not None: |
| nodelist.append(self.else_) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_)) |
| |
| class TryFinally(Node): |
| def __init__(self, body, final, lineno=None): |
| self.body = body |
| self.final = final |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.body, self.final |
| |
| def getChildNodes(self): |
| return self.body, self.final |
| |
| def __repr__(self): |
| return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final)) |
| |
| class Tuple(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 "Tuple(%s)" % (repr(self.nodes),) |
| |
| class UnaryAdd(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 "UnaryAdd(%s)" % (repr(self.expr),) |
| |
| class UnarySub(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 "UnarySub(%s)" % (repr(self.expr),) |
| |
| class While(Node): |
| def __init__(self, test, body, else_, lineno=None): |
| self.test = test |
| self.body = body |
| self.else_ = else_ |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.test) |
| children.append(self.body) |
| children.append(self.else_) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.append(self.test) |
| nodelist.append(self.body) |
| if self.else_ is not None: |
| nodelist.append(self.else_) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_)) |
| |
| class With(Node): |
| def __init__(self, expr, vars, body, lineno=None): |
| self.expr = expr |
| self.vars = vars |
| self.body = body |
| self.lineno = lineno |
| |
| def getChildren(self): |
| children = [] |
| children.append(self.expr) |
| children.append(self.vars) |
| children.append(self.body) |
| return tuple(children) |
| |
| def getChildNodes(self): |
| nodelist = [] |
| nodelist.append(self.expr) |
| if self.vars is not None: |
| nodelist.append(self.vars) |
| nodelist.append(self.body) |
| return tuple(nodelist) |
| |
| def __repr__(self): |
| return "With(%s, %s, %s)" % (repr(self.expr), repr(self.vars), repr(self.body)) |
| |
| class Yield(Node): |
| def __init__(self, value, lineno=None): |
| self.value = value |
| self.lineno = lineno |
| |
| def getChildren(self): |
| return self.value, |
| |
| def getChildNodes(self): |
| return self.value, |
| |
| def __repr__(self): |
| return "Yield(%s)" % (repr(self.value),) |
| |
| for name, obj in globals().items(): |
| if isinstance(obj, type) and issubclass(obj, Node): |
| nodes[name.lower()] = obj |
