"""Python abstract syntax node definitions
-This file is automatically generated.
+This file is automatically generated by Tools/compiler/astgen.py
"""
-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:
+ if t is tuple or t is list:
for elt2 in flatten(elt):
l.append(elt2)
else:
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
+class Node:
+ """Abstract base class for ast nodes."""
def getChildren(self):
pass # implemented by subclasses
- def asList(self):
- return tuple(asList(self.getChildren()))
+ 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
return "Expression(%s)" % (repr(self.node))
class Add(Node):
- nodes["add"] = "Add"
- def __init__(self, (left, right)):
+ def __init__(self, (left, right), lineno=None):
self.left = left
self.right = right
+ self.lineno = lineno
def getChildren(self):
return self.left, self.right
return "Add((%s, %s))" % (repr(self.left), repr(self.right))
class And(Node):
- nodes["and"] = "And"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "And(%s)" % (repr(self.nodes),)
class AssAttr(Node):
- nodes["assattr"] = "AssAttr"
- def __init__(self, expr, attrname, flags):
+ 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
return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
class AssList(Node):
- nodes["asslist"] = "AssList"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "AssList(%s)" % (repr(self.nodes),)
class AssName(Node):
- nodes["assname"] = "AssName"
- def __init__(self, name, flags):
+ def __init__(self, name, flags, lineno=None):
self.name = name
self.flags = flags
+ self.lineno = lineno
def getChildren(self):
return self.name, self.flags
return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
class AssTuple(Node):
- nodes["asstuple"] = "AssTuple"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "AssTuple(%s)" % (repr(self.nodes),)
class Assert(Node):
- nodes["assert"] = "Assert"
- def __init__(self, test, fail):
+ def __init__(self, test, fail, lineno=None):
self.test = test
self.fail = fail
+ self.lineno = lineno
def getChildren(self):
children = []
def getChildNodes(self):
nodelist = []
nodelist.append(self.test)
- if self.fail is not None: nodelist.append(self.fail)
+ 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):
- nodes["assign"] = "Assign"
- def __init__(self, nodes, expr):
+ def __init__(self, nodes, expr, lineno=None):
self.nodes = nodes
self.expr = expr
+ self.lineno = lineno
def getChildren(self):
children = []
return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
class AugAssign(Node):
- nodes["augassign"] = "AugAssign"
- def __init__(self, node, op, expr):
+ 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
return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
class Backquote(Node):
- nodes["backquote"] = "Backquote"
- def __init__(self, expr):
+ def __init__(self, expr, lineno=None):
self.expr = expr
+ self.lineno = lineno
def getChildren(self):
return self.expr,
return "Backquote(%s)" % (repr(self.expr),)
class Bitand(Node):
- nodes["bitand"] = "Bitand"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "Bitand(%s)" % (repr(self.nodes),)
class Bitor(Node):
- nodes["bitor"] = "Bitor"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "Bitor(%s)" % (repr(self.nodes),)
class Bitxor(Node):
- nodes["bitxor"] = "Bitxor"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "Bitxor(%s)" % (repr(self.nodes),)
class Break(Node):
- nodes["break"] = "Break"
- def __init__(self, ):
- pass
+ def __init__(self, lineno=None):
+ self.lineno = lineno
def getChildren(self):
return ()
return "Break()"
class CallFunc(Node):
- nodes["callfunc"] = "CallFunc"
- def __init__(self, node, args, star_args = None, dstar_args = None):
+ 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 = []
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)
+ 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):
- nodes["class"] = "Class"
- def __init__(self, name, bases, doc, code):
+ def __init__(self, name, bases, doc, code, lineno=None):
self.name = name
self.bases = bases
self.doc = doc
self.code = code
+ self.lineno = lineno
def getChildren(self):
children = []
return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
class Compare(Node):
- nodes["compare"] = "Compare"
- def __init__(self, expr, ops):
+ def __init__(self, expr, ops, lineno=None):
self.expr = expr
self.ops = ops
+ self.lineno = lineno
def getChildren(self):
children = []
return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
class Const(Node):
- nodes["const"] = "Const"
- def __init__(self, value):
+ def __init__(self, value, lineno=None):
self.value = value
+ self.lineno = lineno
def getChildren(self):
return self.value,
return "Const(%s)" % (repr(self.value),)
class Continue(Node):
- nodes["continue"] = "Continue"
- def __init__(self, ):
- pass
+ def __init__(self, lineno=None):
+ self.lineno = lineno
def getChildren(self):
return ()
return "Continue()"
class Decorators(Node):
- nodes["decorators"] = "Decorators"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
return tuple(flatten(self.nodes))
def getChildNodes(self):
- return flatten_nodes(self.nodes)
+ nodelist = []
+ nodelist.extend(flatten_nodes(self.nodes))
+ return tuple(nodelist)
def __repr__(self):
return "Decorators(%s)" % (repr(self.nodes),)
class Dict(Node):
- nodes["dict"] = "Dict"
- def __init__(self, items):
+ def __init__(self, items, lineno=None):
self.items = items
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.items))
- return tuple(children)
+ return tuple(flatten(self.items))
def getChildNodes(self):
nodelist = []
return "Dict(%s)" % (repr(self.items),)
class Discard(Node):
- nodes["discard"] = "Discard"
- def __init__(self, expr):
+ def __init__(self, expr, lineno=None):
self.expr = expr
+ self.lineno = lineno
def getChildren(self):
return self.expr,
return "Discard(%s)" % (repr(self.expr),)
class Div(Node):
- nodes["div"] = "Div"
- def __init__(self, (left, right)):
+ def __init__(self, (left, right), lineno=None):
self.left = left
self.right = right
+ self.lineno = lineno
def getChildren(self):
return self.left, self.right
return "Div((%s, %s))" % (repr(self.left), repr(self.right))
class Ellipsis(Node):
- nodes["ellipsis"] = "Ellipsis"
- def __init__(self, ):
- pass
+ def __init__(self, lineno=None):
+ self.lineno = lineno
def getChildren(self):
return ()
return "Ellipsis()"
class Exec(Node):
- nodes["exec"] = "Exec"
- def __init__(self, expr, locals, globals):
+ def __init__(self, expr, locals, globals, lineno=None):
self.expr = expr
self.locals = locals
self.globals = globals
+ self.lineno = lineno
def getChildren(self):
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)
+ 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):
- nodes["floordiv"] = "FloorDiv"
- def __init__(self, (left, right)):
+ def __init__(self, (left, right), lineno=None):
self.left = left
self.right = right
+ self.lineno = lineno
def getChildren(self):
return self.left, self.right
return "FloorDiv((%s, %s))" % (repr(self.left), repr(self.right))
class For(Node):
- nodes["for"] = "For"
- def __init__(self, assign, list, body, else_):
+ 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 = []
nodelist.append(self.assign)
nodelist.append(self.list)
nodelist.append(self.body)
- if self.else_ is not None: nodelist.append(self.else_)
+ 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):
- nodes["from"] = "From"
- def __init__(self, modname, names):
+ def __init__(self, modname, names, lineno=None):
self.modname = modname
self.names = names
+ self.lineno = lineno
def getChildren(self):
return self.modname, self.names
return "From(%s, %s)" % (repr(self.modname), repr(self.names))
class Function(Node):
- nodes["function"] = "Function"
- def __init__(self, decorators, name, argnames, defaults, flags, doc, code):
+ def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno=None):
self.decorators = decorators
self.name = name
self.argnames = argnames
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 = []
- if self.decorators:
- children.append(flatten(self.decorators.nodes))
+ children.append(self.decorators)
children.append(self.name)
children.append(self.argnames)
children.extend(flatten(self.defaults))
def getChildNodes(self):
nodelist = []
- if self.decorators:
- nodelist.extend(flatten_nodes(self.decorators.nodes))
+ if self.decorators is not None:
+ nodelist.append(self.decorators)
nodelist.extend(flatten_nodes(self.defaults))
nodelist.append(self.code)
return tuple(nodelist)
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):
- nodes["genexpr"] = "GenExpr"
- def __init__(self, code):
+ def __init__(self, code, lineno=None):
self.code = code
+ self.lineno = lineno
self.argnames = ['[outmost-iterable]']
self.varargs = self.kwargs = None
-
+
def getChildren(self):
return "GenExpr(%s)" % (repr(self.code),)
class GenExprFor(Node):
- nodes["genexprfor"] = "GenExprFor"
- def __init__(self, assign, iter, ifs):
+ def __init__(self, assign, iter, ifs, lineno=None):
self.assign = assign
self.iter = iter
self.ifs = ifs
+ self.lineno = lineno
self.is_outmost = False
return "GenExprFor(%s, %s, %s)" % (repr(self.assign), repr(self.iter), repr(self.ifs))
class GenExprIf(Node):
- nodes["genexprif"] = "GenExprIf"
- def __init__(self, test):
+ def __init__(self, test, lineno=None):
self.test = test
+ self.lineno = lineno
def getChildren(self):
return self.test,
return "GenExprIf(%s)" % (repr(self.test),)
class GenExprInner(Node):
- nodes["genexprinner"] = "GenExprInner"
- def __init__(self, expr, quals):
+ def __init__(self, expr, quals, lineno=None):
self.expr = expr
self.quals = quals
+ self.lineno = lineno
def getChildren(self):
children = []
return "GenExprInner(%s, %s)" % (repr(self.expr), repr(self.quals))
class Getattr(Node):
- nodes["getattr"] = "Getattr"
- def __init__(self, expr, attrname):
+ def __init__(self, expr, attrname, lineno=None):
self.expr = expr
self.attrname = attrname
+ self.lineno = lineno
def getChildren(self):
return self.expr, self.attrname
return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
class Global(Node):
- nodes["global"] = "Global"
- def __init__(self, names):
+ def __init__(self, names, lineno=None):
self.names = names
+ self.lineno = lineno
def getChildren(self):
return self.names,
return "Global(%s)" % (repr(self.names),)
class If(Node):
- nodes["if"] = "If"
- def __init__(self, tests, else_):
+ def __init__(self, tests, else_, lineno=None):
self.tests = tests
self.else_ = else_
+ self.lineno = lineno
def getChildren(self):
children = []
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.tests))
- if self.else_ is not None: nodelist.append(self.else_)
+ 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 Import(Node):
- nodes["import"] = "Import"
- def __init__(self, names):
+ def __init__(self, names, lineno=None):
self.names = names
+ self.lineno = lineno
def getChildren(self):
return self.names,
return "Import(%s)" % (repr(self.names),)
class Invert(Node):
- nodes["invert"] = "Invert"
- def __init__(self, expr):
+ def __init__(self, expr, lineno=None):
self.expr = expr
+ self.lineno = lineno
def getChildren(self):
return self.expr,
return "Invert(%s)" % (repr(self.expr),)
class Keyword(Node):
- nodes["keyword"] = "Keyword"
- def __init__(self, name, expr):
+ def __init__(self, name, expr, lineno=None):
self.name = name
self.expr = expr
+ self.lineno = lineno
def getChildren(self):
return self.name, self.expr
return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
class Lambda(Node):
- nodes["lambda"] = "Lambda"
- def __init__(self, argnames, defaults, flags, code):
+ 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):
return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
class LeftShift(Node):
- nodes["leftshift"] = "LeftShift"
- def __init__(self, (left, right)):
+ def __init__(self, (left, right), lineno=None):
self.left = left
self.right = right
+ self.lineno = lineno
def getChildren(self):
return self.left, self.right
return "LeftShift((%s, %s))" % (repr(self.left), repr(self.right))
class List(Node):
- nodes["list"] = "List"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "List(%s)" % (repr(self.nodes),)
class ListComp(Node):
- nodes["listcomp"] = "ListComp"
- def __init__(self, expr, quals):
+ def __init__(self, expr, quals, lineno=None):
self.expr = expr
self.quals = quals
+ self.lineno = lineno
def getChildren(self):
children = []
return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
class ListCompFor(Node):
- nodes["listcompfor"] = "ListCompFor"
- def __init__(self, assign, list, ifs):
+ def __init__(self, assign, list, ifs, lineno=None):
self.assign = assign
self.list = list
self.ifs = ifs
+ self.lineno = lineno
def getChildren(self):
children = []
return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
class ListCompIf(Node):
- nodes["listcompif"] = "ListCompIf"
- def __init__(self, test):
+ def __init__(self, test, lineno=None):
self.test = test
+ self.lineno = lineno
def getChildren(self):
return self.test,
return "ListCompIf(%s)" % (repr(self.test),)
class Mod(Node):
- nodes["mod"] = "Mod"
- def __init__(self, (left, right)):
+ def __init__(self, (left, right), lineno=None):
self.left = left
self.right = right
+ self.lineno = lineno
def getChildren(self):
return self.left, self.right
return "Mod((%s, %s))" % (repr(self.left), repr(self.right))
class Module(Node):
- nodes["module"] = "Module"
- def __init__(self, doc, 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
return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
class Mul(Node):
- nodes["mul"] = "Mul"
- def __init__(self, (left, right)):
+ def __init__(self, (left, right), lineno=None):
self.left = left
self.right = right
+ self.lineno = lineno
def getChildren(self):
return self.left, self.right
return "Mul((%s, %s))" % (repr(self.left), repr(self.right))
class Name(Node):
- nodes["name"] = "Name"
- def __init__(self, name):
+ def __init__(self, name, lineno=None):
self.name = name
+ self.lineno = lineno
def getChildren(self):
return self.name,
return "Name(%s)" % (repr(self.name),)
class Not(Node):
- nodes["not"] = "Not"
- def __init__(self, expr):
+ def __init__(self, expr, lineno=None):
self.expr = expr
+ self.lineno = lineno
def getChildren(self):
return self.expr,
return "Not(%s)" % (repr(self.expr),)
class Or(Node):
- nodes["or"] = "Or"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "Or(%s)" % (repr(self.nodes),)
class Pass(Node):
- nodes["pass"] = "Pass"
- def __init__(self, ):
- pass
+ def __init__(self, lineno=None):
+ self.lineno = lineno
def getChildren(self):
return ()
return "Pass()"
class Power(Node):
- nodes["power"] = "Power"
- def __init__(self, (left, right)):
+ def __init__(self, (left, right), lineno=None):
self.left = left
self.right = right
+ self.lineno = lineno
def getChildren(self):
return self.left, self.right
return "Power((%s, %s))" % (repr(self.left), repr(self.right))
class Print(Node):
- nodes["print"] = "Print"
- def __init__(self, nodes, dest):
+ def __init__(self, nodes, dest, lineno=None):
self.nodes = nodes
self.dest = dest
+ self.lineno = lineno
def getChildren(self):
children = []
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
- if self.dest is not None: nodelist.append(self.dest)
+ 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):
- nodes["printnl"] = "Printnl"
- def __init__(self, nodes, dest):
+ def __init__(self, nodes, dest, lineno=None):
self.nodes = nodes
self.dest = dest
+ self.lineno = lineno
def getChildren(self):
children = []
def getChildNodes(self):
nodelist = []
nodelist.extend(flatten_nodes(self.nodes))
- if self.dest is not None: nodelist.append(self.dest)
+ 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):
- nodes["raise"] = "Raise"
- def __init__(self, expr1, expr2, expr3):
+ def __init__(self, expr1, expr2, expr3, lineno=None):
self.expr1 = expr1
self.expr2 = expr2
self.expr3 = expr3
+ self.lineno = lineno
def getChildren(self):
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)
+ 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):
- nodes["return"] = "Return"
- def __init__(self, value):
+ def __init__(self, value, lineno=None):
self.value = value
+ self.lineno = lineno
def getChildren(self):
return self.value,
return "Return(%s)" % (repr(self.value),)
class RightShift(Node):
- nodes["rightshift"] = "RightShift"
- def __init__(self, (left, right)):
+ def __init__(self, (left, right), lineno=None):
self.left = left
self.right = right
+ self.lineno = lineno
def getChildren(self):
return self.left, self.right
return "RightShift((%s, %s))" % (repr(self.left), repr(self.right))
class Slice(Node):
- nodes["slice"] = "Slice"
- def __init__(self, expr, flags, lower, upper):
+ 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 = []
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)
+ 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):
- nodes["sliceobj"] = "Sliceobj"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "Sliceobj(%s)" % (repr(self.nodes),)
class Stmt(Node):
- nodes["stmt"] = "Stmt"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "Stmt(%s)" % (repr(self.nodes),)
class Sub(Node):
- nodes["sub"] = "Sub"
- def __init__(self, (left, right)):
+ def __init__(self, (left, right), lineno=None):
self.left = left
self.right = right
+ self.lineno = lineno
def getChildren(self):
return self.left, self.right
return "Sub((%s, %s))" % (repr(self.left), repr(self.right))
class Subscript(Node):
- nodes["subscript"] = "Subscript"
- def __init__(self, expr, flags, subs):
+ def __init__(self, expr, flags, subs, lineno=None):
self.expr = expr
self.flags = flags
self.subs = subs
+ self.lineno = lineno
def getChildren(self):
children = []
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_):
+ def __init__(self, body, handlers, else_, lineno=None):
self.body = body
self.handlers = handlers
self.else_ = else_
+ self.lineno = lineno
def getChildren(self):
children = []
nodelist = []
nodelist.append(self.body)
nodelist.extend(flatten_nodes(self.handlers))
- if self.else_ is not None: nodelist.append(self.else_)
+ 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):
- nodes["tryfinally"] = "TryFinally"
- def __init__(self, body, final):
+ def __init__(self, body, final, lineno=None):
self.body = body
self.final = final
+ self.lineno = lineno
def getChildren(self):
return self.body, self.final
return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
class Tuple(Node):
- nodes["tuple"] = "Tuple"
- def __init__(self, nodes):
+ def __init__(self, nodes, lineno=None):
self.nodes = nodes
+ self.lineno = lineno
def getChildren(self):
- children = []
- children.extend(flatten(self.nodes))
- return tuple(children)
+ return tuple(flatten(self.nodes))
def getChildNodes(self):
nodelist = []
return "Tuple(%s)" % (repr(self.nodes),)
class UnaryAdd(Node):
- nodes["unaryadd"] = "UnaryAdd"
- def __init__(self, expr):
+ def __init__(self, expr, lineno=None):
self.expr = expr
+ self.lineno = lineno
def getChildren(self):
return self.expr,
return "UnaryAdd(%s)" % (repr(self.expr),)
class UnarySub(Node):
- nodes["unarysub"] = "UnarySub"
- def __init__(self, expr):
+ def __init__(self, expr, lineno=None):
self.expr = expr
+ self.lineno = lineno
def getChildren(self):
return self.expr,
return "UnarySub(%s)" % (repr(self.expr),)
class While(Node):
- nodes["while"] = "While"
- def __init__(self, test, body, else_):
+ def __init__(self, test, body, else_, lineno=None):
self.test = test
self.body = body
self.else_ = else_
+ self.lineno = lineno
def getChildren(self):
children = []
nodelist = []
nodelist.append(self.test)
nodelist.append(self.body)
- if self.else_ is not None: nodelist.append(self.else_)
+ 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 Yield(Node):
- nodes["yield"] = "Yield"
- def __init__(self, value):
+ def __init__(self, value, lineno=None):
self.value = value
+ self.lineno = lineno
def getChildren(self):
return self.value,
def __repr__(self):
return "Yield(%s)" % (repr(self.value),)
-klasses = globals()
-for k in nodes.keys():
- nodes[k] = klasses[nodes[k]]
+for name, obj in globals().items():
+ if isinstance(obj, type) and issubclass(obj, Node):
+ nodes[name.lower()] = obj
#
# Modifications and improvements for Python 2.0 by Jeremy Hylton and
# Mark Hammond
-
+#
+# Some fixes to try to have correct line number on almost all nodes
+# (except Module, Discard and Stmt) added by Sylvain Thenault
+#
# Portions of this file are:
# Copyright (C) 1997-1998 Greg Stein. All Rights Reserved.
#
# http://www.opensource.org/licenses/bsd-license.html
# and replace OWNER, ORGANIZATION, and YEAR as appropriate.
-from ast import *
+from compiler.ast import *
import parser
-# Care must be taken to use only symbols and tokens defined in Python
-# 1.5.2 for code branches executed in 1.5.2
import symbol
import token
import sys
-error = 'walker.error'
+class WalkerError(StandardError):
+ pass
from consts import CO_VARARGS, CO_VARKEYWORDS
from consts import OP_ASSIGN, OP_DELETE, OP_APPLY
def parseFile(path):
- f = open(path)
+ f = open(path, "U")
# XXX The parser API tolerates files without a trailing newline,
# but not strings without a trailing newline. Always add an extra
# newline to the file contents, since we're going through the string
l.append(item)
return l
+def extractLineNo(ast):
+ if not isinstance(ast[1], tuple):
+ # get a terminal node
+ return ast[2]
+ for child in ast[1:]:
+ if isinstance(child, tuple):
+ lineno = extractLineNo(child)
+ if lineno is not None:
+ return lineno
+
def Node(*args):
kind = args[0]
if nodes.has_key(kind):
print nodes[kind], len(args), args
raise
else:
- raise error, "Can't find appropriate Node type: %s" % str(args)
+ raise WalkerEror, "Can't find appropriate Node type: %s" % str(args)
#return apply(ast.Node, args)
class Transformer:
def transform(self, tree):
"""Transform an AST into a modified parse tree."""
- if type(tree) != type(()) and type(tree) != type([]):
+ if not (isinstance(tree, tuple) or isinstance(tree, list)):
tree = parser.ast2tuple(tree, line_info=1)
return self.compile_node(tree)
def parsesuite(self, text):
"""Return a modified parse tree for the given suite text."""
- # Hack for handling non-native line endings on non-DOS like OSs.
- # this can go now we have universal newlines?
- text = text.replace('\x0d', '')
return self.transform(parser.suite(text))
-
+
def parseexpr(self, text):
"""Return a modified parse tree for the given expression text."""
return self.transform(parser.expr(text))
if n == symbol.classdef:
return self.classdef(node[1:])
- raise error, ('unexpected node type', n)
+ raise WalkerEror, ('unexpected node type', n)
def single_input(self, node):
### do we want to do anything about being "interactive" ?
assert isinstance(code, Stmt)
assert isinstance(code.nodes[0], Discard)
del code.nodes[0]
- n = Function(decorators, name, names, defaults, flags, doc, code)
- n.lineno = lineno
- return n
+ return Function(decorators, name, names, defaults, flags, doc, code,
+ lineno=lineno)
def lambdef(self, nodelist):
# lambdef: 'lambda' [varargslist] ':' test
# code for lambda
code = self.com_node(nodelist[-1])
- n = Lambda(names, defaults, flags, code)
- n.lineno = nodelist[1][2]
- return n
+ return Lambda(names, defaults, flags, code, lineno=nodelist[1][2])
def classdef(self, nodelist):
# classdef: 'class' NAME ['(' testlist ')'] ':' suite
assert isinstance(code.nodes[0], Discard)
del code.nodes[0]
- n = Class(name, bases, doc, code)
- n.lineno = nodelist[1][2]
- return n
+ return Class(name, bases, doc, code, lineno=nodelist[1][2])
def stmt(self, nodelist):
return self.com_stmt(nodelist[0])
return Stmt(stmts)
def parameters(self, nodelist):
- raise error
+ raise WalkerEror
def varargslist(self, nodelist):
- raise error
+ raise WalkerEror
def fpdef(self, nodelist):
- raise error
+ raise WalkerEror
def fplist(self, nodelist):
- raise error
+ raise WalkerEror
def dotted_name(self, nodelist):
- raise error
+ raise WalkerEror
def comp_op(self, nodelist):
- raise error
+ raise WalkerEror
def trailer(self, nodelist):
- raise error
+ raise WalkerEror
def sliceop(self, nodelist):
- raise error
+ raise WalkerEror
def argument(self, nodelist):
- raise error
+ raise WalkerEror
# --------------------------------------------------------------
#
en = nodelist[-1]
exprNode = self.lookup_node(en)(en[1:])
if len(nodelist) == 1:
- n = Discard(exprNode)
- n.lineno = exprNode.lineno
- return n
+ return Discard(exprNode, lineno=exprNode.lineno)
if nodelist[1][0] == token.EQUAL:
nodesl = []
for i in range(0, len(nodelist) - 2, 2):
nodesl.append(self.com_assign(nodelist[i], OP_ASSIGN))
- n = Assign(nodesl, exprNode)
- n.lineno = nodelist[1][2]
+ return Assign(nodesl, exprNode, lineno=nodelist[1][2])
else:
lval = self.com_augassign(nodelist[0])
op = self.com_augassign_op(nodelist[1])
- n = AugAssign(lval, op[1], exprNode)
- n.lineno = op[2]
- return n
+ return AugAssign(lval, op[1], exprNode, lineno=op[2])
+ raise WalkerError, "can't get here"
def print_stmt(self, nodelist):
# print ([ test (',' test)* [','] ] | '>>' test [ (',' test)+ [','] ])
for i in range(start, len(nodelist), 2):
items.append(self.com_node(nodelist[i]))
if nodelist[-1][0] == token.COMMA:
- n = Print(items, dest)
- n.lineno = nodelist[0][2]
- return n
- n = Printnl(items, dest)
- n.lineno = nodelist[0][2]
- return n
+ return Print(items, dest, lineno=nodelist[0][2])
+ return Printnl(items, dest, lineno=nodelist[0][2])
def del_stmt(self, nodelist):
return self.com_assign(nodelist[1], OP_DELETE)
def pass_stmt(self, nodelist):
- n = Pass()
- n.lineno = nodelist[0][2]
- return n
+ return Pass(lineno=nodelist[0][2])
def break_stmt(self, nodelist):
- n = Break()
- n.lineno = nodelist[0][2]
- return n
+ return Break(lineno=nodelist[0][2])
def continue_stmt(self, nodelist):
- n = Continue()
- n.lineno = nodelist[0][2]
- return n
+ return Continue(lineno=nodelist[0][2])
def return_stmt(self, nodelist):
# return: [testlist]
if len(nodelist) < 2:
- n = Return(Const(None))
- n.lineno = nodelist[0][2]
- return n
- n = Return(self.com_node(nodelist[1]))
- n.lineno = nodelist[0][2]
- return n
+ return Return(Const(None), lineno=nodelist[0][2])
+ return Return(self.com_node(nodelist[1]), lineno=nodelist[0][2])
def yield_stmt(self, nodelist):
- n = Yield(self.com_node(nodelist[1]))
- n.lineno = nodelist[0][2]
- return n
+ return Yield(self.com_node(nodelist[1]), lineno=nodelist[0][2])
def raise_stmt(self, nodelist):
# raise: [test [',' test [',' test]]]
expr1 = self.com_node(nodelist[1])
else:
expr1 = None
- n = Raise(expr1, expr2, expr3)
- n.lineno = nodelist[0][2]
- return n
+ return Raise(expr1, expr2, expr3, lineno=nodelist[0][2])
def import_stmt(self, nodelist):
# import_stmt: import_name | import_from
def import_name(self, nodelist):
# import_name: 'import' dotted_as_names
- n = Import(self.com_dotted_as_names(nodelist[1]))
- n.lineno = nodelist[0][2]
- return n
+ return Import(self.com_dotted_as_names(nodelist[1]),
+ lineno=nodelist[0][2])
def import_from(self, nodelist):
# import_from: 'from' dotted_name 'import' ('*' |
assert nodelist[2][1] == 'import'
fromname = self.com_dotted_name(nodelist[1])
if nodelist[3][0] == token.STAR:
- n = From(fromname, [('*', None)])
+ # TODO(jhylton): where is the lineno?
+ return From(fromname, [('*', None)])
else:
node = nodelist[3 + (nodelist[3][0] == token.LPAR)]
- n = From(fromname, self.com_import_as_names(node))
- n.lineno = nodelist[0][2]
- return n
+ return From(fromname, self.com_import_as_names(node),
+ lineno=nodelist[0][2])
def global_stmt(self, nodelist):
# global: NAME (',' NAME)*
names = []
for i in range(1, len(nodelist), 2):
names.append(nodelist[i][1])
- n = Global(names)
- n.lineno = nodelist[0][2]
- return n
+ return Global(names, lineno=nodelist[0][2])
def exec_stmt(self, nodelist):
# exec_stmt: 'exec' expr ['in' expr [',' expr]]
else:
expr2 = expr3 = None
- n = Exec(expr1, expr2, expr3)
- n.lineno = nodelist[0][2]
- return n
+ return Exec(expr1, expr2, expr3, lineno=nodelist[0][2])
def assert_stmt(self, nodelist):
# 'assert': test, [',' test]
expr2 = self.com_node(nodelist[3])
else:
expr2 = None
- n = Assert(expr1, expr2)
- n.lineno = nodelist[0][2]
- return n
+ return Assert(expr1, expr2, lineno=nodelist[0][2])
def if_stmt(self, nodelist):
# if: test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
## elseNode.lineno = nodelist[-1][1][2]
else:
elseNode = None
- n = If(tests, elseNode)
- n.lineno = nodelist[0][2]
- return n
+ return If(tests, elseNode, lineno=nodelist[0][2])
def while_stmt(self, nodelist):
# 'while' test ':' suite ['else' ':' suite]
else:
elseNode = None
- n = While(testNode, bodyNode, elseNode)
- n.lineno = nodelist[0][2]
- return n
+ return While(testNode, bodyNode, elseNode, lineno=nodelist[0][2])
def for_stmt(self, nodelist):
# 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
else:
elseNode = None
- n = For(assignNode, listNode, bodyNode, elseNode)
- n.lineno = nodelist[0][2]
- return n
+ return For(assignNode, listNode, bodyNode, elseNode,
+ lineno=nodelist[0][2])
def try_stmt(self, nodelist):
# 'try' ':' suite (except_clause ':' suite)+ ['else' ':' suite]
# 'not' not_test | comparison
result = self.com_node(nodelist[-1])
if len(nodelist) == 2:
- n = Not(result)
- n.lineno = nodelist[0][2]
- return n
+ return Not(result, lineno=nodelist[0][2])
return result
def comparison(self, nodelist):
# the two have very different semantics and results (note that the
# latter form is always true)
- n = Compare(node, results)
- n.lineno = lineno
- return n
+ return Compare(node, results, lineno=lineno)
def expr(self, nodelist):
# xor_expr ('|' xor_expr)*
for i in range(2, len(nodelist), 2):
right = self.com_node(nodelist[i])
if nodelist[i-1][0] == token.LEFTSHIFT:
- node = LeftShift([node, right])
- node.lineno = nodelist[1][2]
+ node = LeftShift([node, right], lineno=nodelist[1][2])
elif nodelist[i-1][0] == token.RIGHTSHIFT:
- node = RightShift([node, right])
- node.lineno = nodelist[1][2]
+ node = RightShift([node, right], lineno=nodelist[1][2])
else:
raise ValueError, "unexpected token: %s" % nodelist[i-1][0]
return node
for i in range(2, len(nodelist), 2):
right = self.com_node(nodelist[i])
if nodelist[i-1][0] == token.PLUS:
- node = Add([node, right])
- node.lineno = nodelist[1][2]
+ node = Add([node, right], lineno=nodelist[1][2])
elif nodelist[i-1][0] == token.MINUS:
- node = Sub([node, right])
- node.lineno = nodelist[1][2]
+ node = Sub([node, right], lineno=nodelist[1][2])
else:
raise ValueError, "unexpected token: %s" % nodelist[i-1][0]
return node
def factor(self, nodelist):
elt = nodelist[0]
t = elt[0]
- node = self.com_node(nodelist[-1])
+ node = self.lookup_node(nodelist[-1])(nodelist[-1][1:])
# need to handle (unary op)constant here...
if t == token.PLUS:
- node = UnaryAdd(node)
- node.lineno = elt[2]
+ return UnaryAdd(node, lineno=elt[2])
elif t == token.MINUS:
- node = UnarySub(node)
- node.lineno = elt[2]
+ return UnarySub(node, lineno=elt[2])
elif t == token.TILDE:
- node = Invert(node)
- node.lineno = elt[2]
+ node = Invert(node, lineno=elt[2])
return node
def power(self, nodelist):
for i in range(1, len(nodelist)):
elt = nodelist[i]
if elt[0] == token.DOUBLESTAR:
- n = Power([node, self.com_node(nodelist[i+1])])
- n.lineno = elt[2]
- return n
+ return Power([node, self.com_node(nodelist[i+1])],
+ lineno=elt[2])
node = self.com_apply_trailer(node, elt)
return node
def atom(self, nodelist):
- n = self._atom_dispatch[nodelist[0][0]](nodelist)
+ return self._atom_dispatch[nodelist[0][0]](nodelist)
n.lineno = nodelist[0][2]
return n
def atom_lpar(self, nodelist):
if nodelist[1][0] == token.RPAR:
- n = Tuple(())
- n.lineno = nodelist[0][2]
- return n
+ return Tuple(())
return self.com_node(nodelist[1])
def atom_lsqb(self, nodelist):
if nodelist[1][0] == token.RSQB:
- n = List(())
- n.lineno = nodelist[0][2]
- return n
+ return List(())
return self.com_list_constructor(nodelist[1])
def atom_lbrace(self, nodelist):
return self.com_dictmaker(nodelist[1])
def atom_backquote(self, nodelist):
- n = Backquote(self.com_node(nodelist[1]))
- n.lineno = nodelist[0][2]
- return n
+ return Backquote(self.com_node(nodelist[1]))
def atom_number(self, nodelist):
### need to verify this matches compile.c
k = eval(nodelist[0][1])
- n = Const(k)
- n.lineno = nodelist[0][2]
- return n
+ return Const(k, lineno=nodelist[0][2])
def decode_literal(self, lit):
if self.encoding:
k = ''
for node in nodelist:
k += self.decode_literal(node[1])
- n = Const(k)
- n.lineno = nodelist[0][2]
- return n
+ return Const(k, lineno=nodelist[0][2])
def atom_name(self, nodelist):
- ### any processing to do?
- n = Name(nodelist[0][1])
- n.lineno = nodelist[0][2]
- return n
+ return Name(nodelist[0][1], lineno=nodelist[0][2])
# --------------------------------------------------------------
#
def lookup_node(self, node):
return self._dispatch[node[0]]
+ _callers = {}
+
def com_node(self, node):
# Note: compile.c has handling in com_node for del_stmt, pass_stmt,
# break_stmt, stmt, small_stmt, flow_stmt, simple_stmt,
i = i + 2
elif len(defaults):
# Treat "(a=1, b)" as "(a=1, b=None)"
+ print nodelist[i]
defaults.append(Const(None))
i = i + 1
def com_try_finally(self, nodelist):
# try_fin_stmt: "try" ":" suite "finally" ":" suite
- n = TryFinally(self.com_node(nodelist[2]),
- self.com_node(nodelist[5]))
- n.lineno = nodelist[0][2]
- return n
+ return TryFinally(self.com_node(nodelist[2]),
+ self.com_node(nodelist[5]),
+ lineno=nodelist[0][2])
def com_try_except(self, nodelist):
# try_except: 'try' ':' suite (except_clause ':' suite)* ['else' suite]
if node[0] == token.NAME:
elseNode = self.com_node(nodelist[i+2])
- n = TryExcept(self.com_node(nodelist[2]), clauses, elseNode)
- n.lineno = nodelist[0][2]
- return n
+ return TryExcept(self.com_node(nodelist[2]), clauses, elseNode,
+ lineno=nodelist[0][2])
def com_augassign_op(self, node):
assert node[0] == symbol.augassign
assigns = []
for i in range(1, len(node), 2):
assigns.append(self.com_assign(node[i], assigning))
- return AssTuple(assigns)
+ return AssTuple(assigns, lineno=extractLineNo(node))
def com_assign_list(self, node, assigning):
assigns = []
raise SyntaxError, "can't assign to list comprehension"
assert node[i + 1][0] == token.COMMA, node[i + 1]
assigns.append(self.com_assign(node[i], assigning))
- return AssList(assigns)
+ return AssList(assigns, lineno=extractLineNo(node))
def com_assign_name(self, node, assigning):
- n = AssName(node[1], assigning)
- n.lineno = node[2]
- return n
+ return AssName(node[1], assigning, lineno=node[2])
def com_assign_trailer(self, primary, node, assigning):
t = node[1][0]
raise SyntaxError, "unknown trailer type: %s" % t
def com_assign_attr(self, primary, node, assigning):
- return AssAttr(primary, node[1], assigning)
+ return AssAttr(primary, node[1], assigning, lineno=node[-1])
def com_binary(self, constructor, nodelist):
"Compile 'NODE (OP NODE)*' into (type, [ node1, ..., nodeN ])."
for i in range(0, l, 2):
n = nodelist[i]
items.append(self.lookup_node(n)(n[1:]))
- return constructor(items)
+ return constructor(items, lineno=extractLineNo(nodelist))
def com_stmt(self, node):
result = self.lookup_node(node)(node[1:])
return Stmt([result])
def com_append_stmt(self, stmts, node):
- result = self.com_node(node)
+ result = self.lookup_node(node)(node[1:])
assert result is not None
if isinstance(result, Stmt):
stmts.extend(result.nodes)
elif nodelist[i][0] == token.COMMA:
continue
values.append(self.com_node(nodelist[i]))
- return List(values)
+ return List(values, lineno=values[0].lineno)
def com_list_comprehension(self, expr, node):
# list_iter: list_for | list_if
node = self.com_list_iter(node[5])
elif t == 'if':
test = self.com_node(node[2])
- newif = ListCompIf(test)
- newif.lineno = node[1][2]
+ newif = ListCompIf(test, lineno=node[1][2])
newfor.ifs.append(newif)
if len(node) == 3:
node = None
raise SyntaxError, \
("unexpected list comprehension element: %s %d"
% (node, lineno))
- n = ListComp(expr, fors)
- n.lineno = lineno
- return n
+ return ListComp(expr, fors, lineno=lineno)
def com_list_iter(self, node):
assert node[0] == symbol.list_iter
if t == 'for':
assignNode = self.com_assign(node[2], OP_ASSIGN)
genNode = self.com_node(node[4])
- newfor = GenExprFor(assignNode, genNode, [])
- newfor.lineno = node[1][2]
+ newfor = GenExprFor(assignNode, genNode, [],
+ lineno=node[1][2])
fors.append(newfor)
if (len(node)) == 5:
node = None
node = self.com_gen_iter(node[5])
elif t == 'if':
test = self.com_node(node[2])
- newif = GenExprIf(test)
- newif.lineno = node[1][2]
+ newif = GenExprIf(test, lineno=node[1][2])
newfor.ifs.append(newif)
if len(node) == 3:
node = None
("unexpected generator expression element: %s %d"
% (node, lineno))
fors[0].is_outmost = True
- n = GenExpr(GenExprInner(expr, fors))
- n.lineno = lineno
- return n
+ return GenExpr(GenExprInner(expr, fors), lineno=lineno)
def com_gen_iter(self, node):
assert node[0] == symbol.gen_iter
def com_select_member(self, primaryNode, nodelist):
if nodelist[0] != token.NAME:
raise SyntaxError, "member must be a name"
- n = Getattr(primaryNode, nodelist[1])
- n.lineno = nodelist[2]
- return n
+ return Getattr(primaryNode, nodelist[1], lineno=nodelist[2])
def com_call_function(self, primaryNode, nodelist):
if nodelist[0] == token.RPAR:
- return CallFunc(primaryNode, [])
+ return CallFunc(primaryNode, [], lineno=extractLineNo(nodelist))
args = []
kw = 0
len_nodelist = len(nodelist)
dstar_node = self.com_node(ch)
else:
raise SyntaxError, 'unknown node type: %s' % tok
-
- return CallFunc(primaryNode, args, star_node, dstar_node)
+ return CallFunc(primaryNode, args, star_node, dstar_node,
+ lineno=extractLineNo(nodelist))
def com_argument(self, nodelist, kw):
if len(nodelist) == 3 and nodelist[2][0] == symbol.gen_for:
n = n[1]
if n[0] != token.NAME:
raise SyntaxError, "keyword can't be an expression (%s)"%n[0]
- node = Keyword(n[1], result)
- node.lineno = n[2]
+ node = Keyword(n[1], result, lineno=n[2])
return 1, node
def com_subscriptlist(self, primary, nodelist, assigning):
subscripts = []
for i in range(1, len(nodelist), 2):
subscripts.append(self.com_subscript(nodelist[i]))
-
- return Subscript(primary, assigning, subscripts)
+ return Subscript(primary, assigning, subscripts,
+ lineno=extractLineNo(nodelist))
def com_subscript(self, node):
# slice_item: expression | proper_slice | ellipsis
items.append(Const(None))
else:
items.append(self.com_node(ch[2]))
-
- return Sliceobj(items)
+ return Sliceobj(items, lineno=extractLineNo(node))
def com_slice(self, primary, node, assigning):
# short_slice: [lower_bound] ":" [upper_bound]
elif len(node) == 4:
lower = self.com_node(node[1])
upper = self.com_node(node[3])
- return Slice(primary, assigning, lower, upper)
+ return Slice(primary, assigning, lower, upper,
+ lineno=extractLineNo(node))
def get_docstring(self, node, n=None):
if n is None:
else:
compiler.compile(buf, basename, "exec")
+ def testLineNo(self):
+ # Test that all nodes except Module have a correct lineno attribute.
+ filename = __file__
+ if filename.endswith(".pyc") or filename.endswith(".pyo"):
+ filename = filename[:-1]
+ tree = compiler.parseFile(filename)
+ self.check_lineno(tree)
+
+ def check_lineno(self, node):
+ try:
+ self._check_lineno(node)
+ except AssertionError:
+ print node.__class__, node.lineno
+ raise
+
+ def _check_lineno(self, node):
+ if not node.__class__ in NOLINENO:
+ self.assert_(isinstance(node.lineno, int),
+ "lineno=%s on %s" % (node.lineno, node.__class__))
+ self.assert_(node.lineno > 0,
+ "lineno=%s on %s" % (node.lineno, node.__class__))
+ for child in node.getChildNodes():
+ self.check_lineno(child)
+
+NOLINENO = (compiler.ast.Module, compiler.ast.Stmt, compiler.ast.Discard)
+
+###############################################################################
+# code below is just used to trigger some possible errors, for the benefit of
+# testLineNo
+###############################################################################
+
+class Toto:
+ """docstring"""
+ pass
+
+a, b = 2, 3
+[c, d] = 5, 6
+l = [(x, y) for x, y in zip(range(5), range(5,10))]
+l[0]
+l[3:4]
+if l:
+ pass
+else:
+ a, b = b, a
+
+try:
+ print yo
+except:
+ yo = 3
+else:
+ yo += 3
+
+try:
+ a += b
+finally:
+ b = 0
+
+###############################################################################
+
def test_main():
global TEST_ALL
TEST_ALL = test.test_support.is_resource_enabled("compiler")
assert vals['b'] == 2
def test_main():
- test_support.run_unittest(
- Tests
- )
+ test_support.run_unittest(Tests)
if __name__ == "__main__":
test_main()
Ken Stox
Daniel Stutzbach
Paul Swartz
+Thenault Sylvain
Geoff Talvola
William Tanksley
Christian Tanzer
def gen_source(self):
buf = StringIO()
print >> buf, "class %s(Node):" % self.name
- print >> buf, ' nodes["%s"] = "%s"' % (self.name.lower(), self.name)
self._gen_init(buf)
print >> buf
self._gen_getChildren(buf)
return buf.read()
def _gen_init(self, buf):
- print >> buf, " def __init__(self, %s):" % self.args
+ if self.args:
+ print >> buf, " def __init__(self, %s, lineno=None):" % self.args
+ else:
+ print >> buf, " def __init__(self, lineno=None):"
if self.argnames:
for name in self.argnames:
print >> buf, " self.%s = %s" % (name, name)
- else:
- print >> buf, " pass"
+ print >> buf, " self.lineno = lineno"
if self.init:
print >> buf, "".join([" " + line for line in self.init])
else:
print >> buf, " return %s" % clist
else:
- print >> buf, " children = []"
- template = " children.%s(%sself.%s%s)"
- for name in self.argnames:
- if self.argprops[name] == P_NESTED:
- print >> buf, template % ("extend", "flatten(",
- name, ")")
- else:
- print >> buf, template % ("append", "", name, "")
- print >> buf, " return tuple(children)"
+ if len(self.argnames) == 1:
+ print >> buf, " return tuple(flatten(self.%s))" % self.argnames[0]
+ else:
+ print >> buf, " children = []"
+ template = " children.%s(%sself.%s%s)"
+ for name in self.argnames:
+ if self.argprops[name] == P_NESTED:
+ print >> buf, template % ("extend", "flatten(",
+ name, ")")
+ else:
+ print >> buf, template % ("append", "", name, "")
+ print >> buf, " return tuple(children)"
def _gen_getChildNodes(self, buf):
print >> buf, " def getChildNodes(self):"
template = " nodelist.%s(%sself.%s%s)"
for name in self.argnames:
if self.argprops[name] == P_NONE:
- tmp = (" if self.%s is not None:"
+ tmp = (" if self.%s is not None:\n"
" nodelist.append(self.%s)")
print >> buf, tmp % (name, name)
elif self.argprops[name] == P_NESTED:
### PROLOGUE
"""Python abstract syntax node definitions
-This file is automatically generated.
+This file is automatically generated by Tools/compiler/astgen.py
"""
-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:
+ if t is tuple or t is list:
for elt2 in flatten(elt):
l.append(elt2)
else:
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
+class Node:
+ """Abstract base class for ast nodes."""
def getChildren(self):
pass # implemented by subclasses
- def asList(self):
- return tuple(asList(self.getChildren()))
+ 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
return "Expression(%s)" % (repr(self.node))
### EPILOGUE
-klasses = globals()
-for k in nodes.keys():
- nodes[k] = klasses[nodes[k]]
+for name, obj in globals().items():
+ if isinstance(obj, type) and issubclass(obj, Node):
+ nodes[name.lower()] = obj
projects / python / commitdiff