| """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 |