1242 lines
31 KiB
Python
1242 lines
31 KiB
Python
"""Python abstract syntax node definitions
|
|
|
|
This file is automatically generated.
|
|
"""
|
|
from types import TupleType, ListType
|
|
from consts import CO_VARARGS, CO_VARKEYWORDS
|
|
|
|
def flatten(list):
|
|
l = []
|
|
for elt in list:
|
|
t = type(elt)
|
|
if t is TupleType or t is ListType:
|
|
for elt2 in flatten(elt):
|
|
l.append(elt2)
|
|
else:
|
|
l.append(elt)
|
|
return l
|
|
|
|
def flatten_nodes(list):
|
|
return [n for n in flatten(list) if isinstance(n, Node)]
|
|
|
|
def asList(nodearg):
|
|
l = []
|
|
for item in nodearg:
|
|
if hasattr(item, "asList"):
|
|
l.append(item.asList())
|
|
else:
|
|
t = type(item)
|
|
if t is TupleType or t is ListType:
|
|
l.append(tuple(asList(item)))
|
|
else:
|
|
l.append(item)
|
|
return l
|
|
|
|
nodes = {}
|
|
|
|
class Node: # an abstract base class
|
|
lineno = None # provide a lineno for nodes that don't have one
|
|
def getType(self):
|
|
pass # implemented by subclass
|
|
def getChildren(self):
|
|
pass # implemented by subclasses
|
|
def asList(self):
|
|
return tuple(asList(self.getChildren()))
|
|
def getChildNodes(self):
|
|
pass # implemented by subclasses
|
|
|
|
class EmptyNode(Node):
|
|
pass
|
|
|
|
class Slice(Node):
|
|
nodes["slice"] = "Slice"
|
|
def __init__(self, expr, flags, lower, upper):
|
|
self.expr = expr
|
|
self.flags = flags
|
|
self.lower = lower
|
|
self.upper = upper
|
|
|
|
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 Const(Node):
|
|
nodes["const"] = "Const"
|
|
def __init__(self, value):
|
|
self.value = value
|
|
|
|
def getChildren(self):
|
|
return self.value,
|
|
|
|
def getChildNodes(self):
|
|
return ()
|
|
|
|
def __repr__(self):
|
|
return "Const(%s)" % (repr(self.value),)
|
|
|
|
class Raise(Node):
|
|
nodes["raise"] = "Raise"
|
|
def __init__(self, expr1, expr2, expr3):
|
|
self.expr1 = expr1
|
|
self.expr2 = expr2
|
|
self.expr3 = expr3
|
|
|
|
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 For(Node):
|
|
nodes["for"] = "For"
|
|
def __init__(self, assign, list, body, else_):
|
|
self.assign = assign
|
|
self.list = list
|
|
self.body = body
|
|
self.else_ = else_
|
|
|
|
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 AssTuple(Node):
|
|
nodes["asstuple"] = "AssTuple"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.nodes))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "AssTuple(%s)" % (repr(self.nodes),)
|
|
|
|
class Mul(Node):
|
|
nodes["mul"] = "Mul"
|
|
def __init__(self, (left, right)):
|
|
self.left = left
|
|
self.right = right
|
|
|
|
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 Invert(Node):
|
|
nodes["invert"] = "Invert"
|
|
def __init__(self, expr):
|
|
self.expr = expr
|
|
|
|
def getChildren(self):
|
|
return self.expr,
|
|
|
|
def getChildNodes(self):
|
|
return self.expr,
|
|
|
|
def __repr__(self):
|
|
return "Invert(%s)" % (repr(self.expr),)
|
|
|
|
class RightShift(Node):
|
|
nodes["rightshift"] = "RightShift"
|
|
def __init__(self, (left, right)):
|
|
self.left = left
|
|
self.right = right
|
|
|
|
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 AssList(Node):
|
|
nodes["asslist"] = "AssList"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.nodes))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "AssList(%s)" % (repr(self.nodes),)
|
|
|
|
class From(Node):
|
|
nodes["from"] = "From"
|
|
def __init__(self, modname, names):
|
|
self.modname = modname
|
|
self.names = names
|
|
|
|
def getChildren(self):
|
|
return self.modname, self.names
|
|
|
|
def getChildNodes(self):
|
|
return ()
|
|
|
|
def __repr__(self):
|
|
return "From(%s, %s)" % (repr(self.modname), repr(self.names))
|
|
|
|
class Getattr(Node):
|
|
nodes["getattr"] = "Getattr"
|
|
def __init__(self, expr, attrname):
|
|
self.expr = expr
|
|
self.attrname = attrname
|
|
|
|
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 Dict(Node):
|
|
nodes["dict"] = "Dict"
|
|
def __init__(self, items):
|
|
self.items = items
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.items))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.items))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "Dict(%s)" % (repr(self.items),)
|
|
|
|
class Module(Node):
|
|
nodes["module"] = "Module"
|
|
def __init__(self, doc, node):
|
|
self.doc = doc
|
|
self.node = node
|
|
|
|
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 Expression(Node):
|
|
# Expression is an artifical 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 UnaryAdd(Node):
|
|
nodes["unaryadd"] = "UnaryAdd"
|
|
def __init__(self, expr):
|
|
self.expr = expr
|
|
|
|
def getChildren(self):
|
|
return self.expr,
|
|
|
|
def getChildNodes(self):
|
|
return self.expr,
|
|
|
|
def __repr__(self):
|
|
return "UnaryAdd(%s)" % (repr(self.expr),)
|
|
|
|
class Ellipsis(Node):
|
|
nodes["ellipsis"] = "Ellipsis"
|
|
def __init__(self, ):
|
|
pass
|
|
|
|
def getChildren(self):
|
|
return ()
|
|
|
|
def getChildNodes(self):
|
|
return ()
|
|
|
|
def __repr__(self):
|
|
return "Ellipsis()"
|
|
|
|
class Print(Node):
|
|
nodes["print"] = "Print"
|
|
def __init__(self, nodes, dest):
|
|
self.nodes = nodes
|
|
self.dest = dest
|
|
|
|
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 Import(Node):
|
|
nodes["import"] = "Import"
|
|
def __init__(self, names):
|
|
self.names = names
|
|
|
|
def getChildren(self):
|
|
return self.names,
|
|
|
|
def getChildNodes(self):
|
|
return ()
|
|
|
|
def __repr__(self):
|
|
return "Import(%s)" % (repr(self.names),)
|
|
|
|
class Subscript(Node):
|
|
nodes["subscript"] = "Subscript"
|
|
def __init__(self, expr, flags, subs):
|
|
self.expr = expr
|
|
self.flags = flags
|
|
self.subs = subs
|
|
|
|
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):
|
|
nodes["tryexcept"] = "TryExcept"
|
|
def __init__(self, body, handlers, else_):
|
|
self.body = body
|
|
self.handlers = handlers
|
|
self.else_ = else_
|
|
|
|
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 Or(Node):
|
|
nodes["or"] = "Or"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.nodes))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "Or(%s)" % (repr(self.nodes),)
|
|
|
|
class Name(Node):
|
|
nodes["name"] = "Name"
|
|
def __init__(self, name):
|
|
self.name = name
|
|
|
|
def getChildren(self):
|
|
return self.name,
|
|
|
|
def getChildNodes(self):
|
|
return ()
|
|
|
|
def __repr__(self):
|
|
return "Name(%s)" % (repr(self.name),)
|
|
|
|
class Function(Node):
|
|
nodes["function"] = "Function"
|
|
def __init__(self, name, argnames, defaults, flags, doc, code):
|
|
self.name = name
|
|
self.argnames = argnames
|
|
self.defaults = defaults
|
|
self.flags = flags
|
|
self.doc = doc
|
|
self.code = code
|
|
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.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 = []
|
|
nodelist.extend(flatten_nodes(self.defaults))
|
|
nodelist.append(self.code)
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "Function(%s, %s, %s, %s, %s, %s)" % (repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
|
|
|
|
class Assert(Node):
|
|
nodes["assert"] = "Assert"
|
|
def __init__(self, test, fail):
|
|
self.test = test
|
|
self.fail = fail
|
|
|
|
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 Return(Node):
|
|
nodes["return"] = "Return"
|
|
def __init__(self, value):
|
|
self.value = value
|
|
|
|
def getChildren(self):
|
|
return self.value,
|
|
|
|
def getChildNodes(self):
|
|
return self.value,
|
|
|
|
def __repr__(self):
|
|
return "Return(%s)" % (repr(self.value),)
|
|
|
|
class Power(Node):
|
|
nodes["power"] = "Power"
|
|
def __init__(self, (left, right)):
|
|
self.left = left
|
|
self.right = right
|
|
|
|
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 Exec(Node):
|
|
nodes["exec"] = "Exec"
|
|
def __init__(self, expr, locals, globals):
|
|
self.expr = expr
|
|
self.locals = locals
|
|
self.globals = globals
|
|
|
|
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 Stmt(Node):
|
|
nodes["stmt"] = "Stmt"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.nodes))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "Stmt(%s)" % (repr(self.nodes),)
|
|
|
|
class Sliceobj(Node):
|
|
nodes["sliceobj"] = "Sliceobj"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.nodes))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "Sliceobj(%s)" % (repr(self.nodes),)
|
|
|
|
class Break(Node):
|
|
nodes["break"] = "Break"
|
|
def __init__(self, ):
|
|
pass
|
|
|
|
def getChildren(self):
|
|
return ()
|
|
|
|
def getChildNodes(self):
|
|
return ()
|
|
|
|
def __repr__(self):
|
|
return "Break()"
|
|
|
|
class Bitand(Node):
|
|
nodes["bitand"] = "Bitand"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.nodes))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "Bitand(%s)" % (repr(self.nodes),)
|
|
|
|
class FloorDiv(Node):
|
|
nodes["floordiv"] = "FloorDiv"
|
|
def __init__(self, (left, right)):
|
|
self.left = left
|
|
self.right = right
|
|
|
|
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 TryFinally(Node):
|
|
nodes["tryfinally"] = "TryFinally"
|
|
def __init__(self, body, final):
|
|
self.body = body
|
|
self.final = final
|
|
|
|
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 Not(Node):
|
|
nodes["not"] = "Not"
|
|
def __init__(self, expr):
|
|
self.expr = expr
|
|
|
|
def getChildren(self):
|
|
return self.expr,
|
|
|
|
def getChildNodes(self):
|
|
return self.expr,
|
|
|
|
def __repr__(self):
|
|
return "Not(%s)" % (repr(self.expr),)
|
|
|
|
class Class(Node):
|
|
nodes["class"] = "Class"
|
|
def __init__(self, name, bases, doc, code):
|
|
self.name = name
|
|
self.bases = bases
|
|
self.doc = doc
|
|
self.code = code
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.append(self.name)
|
|
children.extend(flatten(self.bases))
|
|
children.append(self.doc)
|
|
children.append(self.code)
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.bases))
|
|
nodelist.append(self.code)
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
|
|
|
|
class Mod(Node):
|
|
nodes["mod"] = "Mod"
|
|
def __init__(self, (left, right)):
|
|
self.left = left
|
|
self.right = right
|
|
|
|
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 Printnl(Node):
|
|
nodes["printnl"] = "Printnl"
|
|
def __init__(self, nodes, dest):
|
|
self.nodes = nodes
|
|
self.dest = dest
|
|
|
|
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 Tuple(Node):
|
|
nodes["tuple"] = "Tuple"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.nodes))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "Tuple(%s)" % (repr(self.nodes),)
|
|
|
|
class AssAttr(Node):
|
|
nodes["assattr"] = "AssAttr"
|
|
def __init__(self, expr, attrname, flags):
|
|
self.expr = expr
|
|
self.attrname = attrname
|
|
self.flags = flags
|
|
|
|
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 Keyword(Node):
|
|
nodes["keyword"] = "Keyword"
|
|
def __init__(self, name, expr):
|
|
self.name = name
|
|
self.expr = expr
|
|
|
|
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 AugAssign(Node):
|
|
nodes["augassign"] = "AugAssign"
|
|
def __init__(self, node, op, expr):
|
|
self.node = node
|
|
self.op = op
|
|
self.expr = expr
|
|
|
|
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 List(Node):
|
|
nodes["list"] = "List"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.nodes))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "List(%s)" % (repr(self.nodes),)
|
|
|
|
class Yield(Node):
|
|
nodes["yield"] = "Yield"
|
|
def __init__(self, value):
|
|
self.value = value
|
|
|
|
def getChildren(self):
|
|
return self.value,
|
|
|
|
def getChildNodes(self):
|
|
return self.value,
|
|
|
|
def __repr__(self):
|
|
return "Yield(%s)" % (repr(self.value),)
|
|
|
|
class LeftShift(Node):
|
|
nodes["leftshift"] = "LeftShift"
|
|
def __init__(self, (left, right)):
|
|
self.left = left
|
|
self.right = right
|
|
|
|
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 AssName(Node):
|
|
nodes["assname"] = "AssName"
|
|
def __init__(self, name, flags):
|
|
self.name = name
|
|
self.flags = flags
|
|
|
|
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 While(Node):
|
|
nodes["while"] = "While"
|
|
def __init__(self, test, body, else_):
|
|
self.test = test
|
|
self.body = body
|
|
self.else_ = else_
|
|
|
|
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 Continue(Node):
|
|
nodes["continue"] = "Continue"
|
|
def __init__(self, ):
|
|
pass
|
|
|
|
def getChildren(self):
|
|
return ()
|
|
|
|
def getChildNodes(self):
|
|
return ()
|
|
|
|
def __repr__(self):
|
|
return "Continue()"
|
|
|
|
class Backquote(Node):
|
|
nodes["backquote"] = "Backquote"
|
|
def __init__(self, expr):
|
|
self.expr = expr
|
|
|
|
def getChildren(self):
|
|
return self.expr,
|
|
|
|
def getChildNodes(self):
|
|
return self.expr,
|
|
|
|
def __repr__(self):
|
|
return "Backquote(%s)" % (repr(self.expr),)
|
|
|
|
class Discard(Node):
|
|
nodes["discard"] = "Discard"
|
|
def __init__(self, expr):
|
|
self.expr = expr
|
|
|
|
def getChildren(self):
|
|
return self.expr,
|
|
|
|
def getChildNodes(self):
|
|
return self.expr,
|
|
|
|
def __repr__(self):
|
|
return "Discard(%s)" % (repr(self.expr),)
|
|
|
|
class Div(Node):
|
|
nodes["div"] = "Div"
|
|
def __init__(self, (left, right)):
|
|
self.left = left
|
|
self.right = right
|
|
|
|
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 Assign(Node):
|
|
nodes["assign"] = "Assign"
|
|
def __init__(self, nodes, expr):
|
|
self.nodes = nodes
|
|
self.expr = expr
|
|
|
|
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 Lambda(Node):
|
|
nodes["lambda"] = "Lambda"
|
|
def __init__(self, argnames, defaults, flags, code):
|
|
self.argnames = argnames
|
|
self.defaults = defaults
|
|
self.flags = flags
|
|
self.code = code
|
|
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 And(Node):
|
|
nodes["and"] = "And"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.nodes))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "And(%s)" % (repr(self.nodes),)
|
|
|
|
class Compare(Node):
|
|
nodes["compare"] = "Compare"
|
|
def __init__(self, expr, ops):
|
|
self.expr = expr
|
|
self.ops = ops
|
|
|
|
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 Bitor(Node):
|
|
nodes["bitor"] = "Bitor"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
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):
|
|
nodes["bitxor"] = "Bitxor"
|
|
def __init__(self, nodes):
|
|
self.nodes = nodes
|
|
|
|
def getChildren(self):
|
|
children = []
|
|
children.extend(flatten(self.nodes))
|
|
return tuple(children)
|
|
|
|
def getChildNodes(self):
|
|
nodelist = []
|
|
nodelist.extend(flatten_nodes(self.nodes))
|
|
return tuple(nodelist)
|
|
|
|
def __repr__(self):
|
|
return "Bitxor(%s)" % (repr(self.nodes),)
|
|
|
|
class CallFunc(Node):
|
|
nodes["callfunc"] = "CallFunc"
|
|
def __init__(self, node, args, star_args = None, dstar_args = None):
|
|
self.node = node
|
|
self.args = args
|
|
self.star_args = star_args
|
|
self.dstar_args = dstar_args
|
|
|
|
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 Global(Node):
|
|
nodes["global"] = "Global"
|
|
def __init__(self, names):
|
|
self.names = names
|
|
|
|
def getChildren(self):
|
|
return self.names,
|
|
|
|
def getChildNodes(self):
|
|
return ()
|
|
|
|
def __repr__(self):
|
|
return "Global(%s)" % (repr(self.names),)
|
|
|
|
class Add(Node):
|
|
nodes["add"] = "Add"
|
|
def __init__(self, (left, right)):
|
|
self.left = left
|
|
self.right = right
|
|
|
|
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 ListCompIf(Node):
|
|
nodes["listcompif"] = "ListCompIf"
|
|
def __init__(self, test):
|
|
self.test = test
|
|
|
|
def getChildren(self):
|
|
return self.test,
|
|
|
|
def getChildNodes(self):
|
|
return self.test,
|
|
|
|
def __repr__(self):
|
|
return "ListCompIf(%s)" % (repr(self.test),)
|
|
|
|
class Sub(Node):
|
|
nodes["sub"] = "Sub"
|
|
def __init__(self, (left, right)):
|
|
self.left = left
|
|
self.right = right
|
|
|
|
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 Pass(Node):
|
|
nodes["pass"] = "Pass"
|
|
def __init__(self, ):
|
|
pass
|
|
|
|
def getChildren(self):
|
|
return ()
|
|
|
|
def getChildNodes(self):
|
|
return ()
|
|
|
|
def __repr__(self):
|
|
return "Pass()"
|
|
|
|
class UnarySub(Node):
|
|
nodes["unarysub"] = "UnarySub"
|
|
def __init__(self, expr):
|
|
self.expr = expr
|
|
|
|
def getChildren(self):
|
|
return self.expr,
|
|
|
|
def getChildNodes(self):
|
|
return self.expr,
|
|
|
|
def __repr__(self):
|
|
return "UnarySub(%s)" % (repr(self.expr),)
|
|
|
|
class If(Node):
|
|
nodes["if"] = "If"
|
|
def __init__(self, tests, else_):
|
|
self.tests = tests
|
|
self.else_ = else_
|
|
|
|
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 ListComp(Node):
|
|
nodes["listcomp"] = "ListComp"
|
|
def __init__(self, expr, quals):
|
|
self.expr = expr
|
|
self.quals = quals
|
|
|
|
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):
|
|
nodes["listcompfor"] = "ListCompFor"
|
|
def __init__(self, assign, list, ifs):
|
|
self.assign = assign
|
|
self.list = list
|
|
self.ifs = ifs
|
|
|
|
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))
|
|
|
|
klasses = globals()
|
|
for k in nodes.keys():
|
|
nodes[k] = klasses[nodes[k]]
|