Skip to content

C
cpython
Kaydet (Commit) 628d289d authored tarafından Jeremy Hylton's avatar Jeremy Hylton
Dosyalara gözat
Seçenekler

Generated from rev 1.1 of ast.txt

üst 66d2c1f7
Hide whitespace changes
Inline Side-by-side
Showing with 1212 additions and 1354 deletions
Lib/compiler/ast.py
Dosyayı görüntüle @ 628d289d
import types
from consts import CO_VARARGS, CO_VARKEYWORDS
"""Python abstract syntax node definitions
nodes = {}
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:
if type(elt) is types.TupleType:
for elt2 in flatten(elt):
l.append(elt2)
elif type(elt) is types.ListType:
for elt2 in flatten(elt):
l.append(elt2)
else:
l.append(elt)
return l
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 asList(nodes):
l = []
for item in nodes:
if hasattr(item, "asList"):
l.append(item.asList())
else:
if type(item) is types.TupleType:
l.append(tuple(asList(item)))
elif type(item) is types.ListType:
l.append(asList(item))
else:
l.append(item)
return l
l = []
for item in nodes:
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:
def __init__(self, *args):
self._children = args
self.lineno = None
def __getitem__(self, index):
return self._children[index]
def __repr__(self):
return "<Node %s>" % self._children[0]
def __len__(self):
return len(self._children)
def __getslice__(self, low, high):
return self._children[low:high]
def getChildren(self):
return tuple(flatten(self._children[1:]))
def getType(self):
return self._children[0]
def asList(self):
return tuple(asList(self._children))
lineno = None
def getType(self):
pass
def getChildren(self):
# XXX It would be better to generate flat values to begin with
return flatten(self._getChildren())
def asList(self):
return tuple(asList(self.getChildren()))
class EmptyNode(Node):
def __init__(self):
self.lineno = None
class Module(Node):
nodes['module'] = 'Module'
def __init__(self, doc, node):
self.doc = doc
self.node = node
self._children = ('module', doc, node)
def __repr__(self):
return "Module(%s,%s)" % self._children[1:]
class Stmt(Node):
nodes['stmt'] = 'Stmt'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('stmt', nodes)
def __repr__(self):
return "Stmt(%s)" % self._children[1:]
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._children = ('function',
name, argnames, defaults, flags, doc, code)
self.varargs = self.kwargs = None
if flags & CO_VARARGS:
self.varargs = 1
if flags & CO_VARKEYWORDS:
self.kwargs = 1
def __repr__(self):
return "Function(%s,%s,%s,%s,%s,%s)" % self._children[1:]
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._children = ('lambda', argnames, defaults, flags, code)
self.varargs = self.kwargs = None
if flags & CO_VARARGS:
self.varargs = 1
if flags & CO_VARKEYWORDS:
self.kwargs = 1
def __repr__(self):
return "Lambda(%s,%s,%s,%s)" % self._children[1:]
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
self._children = ('class', name, bases, doc, code)
def __repr__(self):
return "Class(%s,%s,%s,%s)" % self._children[1:]
class Pass(EmptyNode):
nodes['pass'] = 'Pass'
_children = ('pass',)
def __repr__(self):
return "Pass()"
class Break(EmptyNode):
nodes['break'] = 'Break'
_children = ('break',)
def __repr__(self):
return "Break()"
class Continue(EmptyNode):
nodes['continue'] = 'Continue'
_children = ('continue',)
def __repr__(self):
return "Continue()"
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_
self._children = ('for', assign, list, body, else_)
def __repr__(self):
return "For(%s,%s,%s,%s)" % self._children[1:]
class While(Node):
nodes['while'] = 'While'
def __init__(self, test, body, else_):
self.test = test
self.body = body
self.else_ = else_
self._children = ('while', test, body, else_)
def __repr__(self):
return "While(%s,%s,%s)" % self._children[1:]
def __init__(self):
self.lineno = None
class If(Node):
"""if: [ (testNode, suiteNode), ...], elseNode"""
nodes['if'] = 'If'
def __init__(self, tests, else_):
self.tests = tests
self.else_ = else_
self._children = ('if', tests, else_)
def __repr__(self):
return "If(%s,%s)" % self._children[1:]
class Exec(Node):
nodes['exec'] = 'Exec'
def __init__(self, expr, locals, globals):
self.expr = expr
self.locals = locals
self.globals = globals
self._children = ('exec', expr, locals, globals)
def __repr__(self):
return "Exec(%s,%s,%s)" % self._children[1:]
class From(Node):
nodes['from'] = 'From'
def __init__(self, modname, names):
self.modname = modname
self.names = names
self._children = ('from', modname, names)
def __repr__(self):
return "From(%s,%s)" % self._children[1:]
class Import(Node):
nodes['import'] = 'Import'
def __init__(self, names):
self.names = names
self._children = ('import', names)
def __repr__(self):
return "Import(%s)" % self._children[1:]
class Raise(Node):
nodes['raise'] = 'Raise'
def __init__(self, expr1, expr2, expr3):
self.expr1 = expr1
self.expr2 = expr2
self.expr3 = expr3
self._children = ('raise', expr1, expr2, expr3)
def __repr__(self):
return "Raise(%s,%s,%s)" % self._children[1:]
class TryFinally(Node):
nodes['tryfinally'] = 'TryFinally'
def __init__(self, body, final):
self.body = body
self.final = final
self._children = ('tryfinally', body, final)
def __repr__(self):
return "TryFinally(%s,%s)" % self._children[1:]
class TryExcept(Node):
"""Try/Except body and handlers
The handlers attribute is a sequence of tuples. The elements of the
tuple are the exception name, the name to bind the exception to, and
the body of the except clause.
"""
nodes['tryexcept'] = 'TryExcept'
def __init__(self, body, handlers, else_):
self.body = body
self.handlers = handlers
self.else_ = else_
self._children = ('tryexcept', body, handlers, else_)
def __repr__(self):
return "TryExcept(%s,%s,%s)" % self._children[1:]
nodes["if"] = "If"
def __init__(self, tests, else_):
self.tests = tests
self.else_ = else_
def _getChildren(self):
return self.tests, self.else_
def __repr__(self):
return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
class Return(Node):
nodes['return'] = 'Return'
def __init__(self, value):
self.value = value
self._children = ('return', value)
def __repr__(self):
return "Return(%s)" % self._children[1:]
class Const(Node):
nodes['const'] = 'Const'
def __init__(self, value):
self.value = value
self._children = ('const', value)
class ListComp(Node):
nodes["listcomp"] = "ListComp"
def __init__(self, expr, quals):
self.expr = expr
self.quals = quals
def _getChildren(self):
return self.expr, self.quals
def __repr__(self):
return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
def __repr__(self):
return "Const(%s)" % self._children[1:]
class Bitor(Node):
nodes["bitor"] = "Bitor"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Bitor(%s)" % (repr(self.nodes),)
class Pass(Node):
nodes["pass"] = "Pass"
def __init__(self, ):
pass
def _getChildren(self):
return ()
def __repr__(self):
return "Pass()"
class Print(Node):
nodes['print'] = 'Print'
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 __repr__(self):
return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
def __init__(self, nodes, dest):
self.nodes = nodes
self.dest = dest
self._children = ('print', nodes, dest)
class Global(Node):
nodes["global"] = "Global"
def __init__(self, names):
self.names = names
def _getChildren(self):
return self.names,
def __repr__(self):
return "Global(%s)" % (repr(self.names),)
def __repr__(self):
return "Print(%s, %s)" % (self._children[1:-1], self._children[-1])
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):
return self.node, self.args, self.star_args, self.dstar_args
def __repr__(self):
return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
class Printnl(Node):
nodes['printnl'] = 'Printnl'
def __init__(self, nodes, dest):
self.nodes = nodes
self.dest = dest
self._children = ('printnl', nodes, dest)
def __repr__(self):
return "Printnl(%s, %s)" % (self._children[1:-1], self._children[-1])
nodes["printnl"] = "Printnl"
def __init__(self, nodes, dest):
self.nodes = nodes
self.dest = dest
def _getChildren(self):
return self.nodes, self.dest
def __repr__(self):
return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
class Discard(Node):
nodes['discard'] = 'Discard'
def __init__(self, expr):
self.expr = expr
self._children = ('discard', expr)
def __repr__(self):
return "Discard(%s)" % self._children[1:]
class Tuple(Node):
nodes["tuple"] = "Tuple"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Tuple(%s)" % (repr(self.nodes),)
class AugAssign(Node):
nodes['augassign'] = 'AugAssign'
class Compare(Node):
nodes["compare"] = "Compare"
def __init__(self, expr, ops):
self.expr = expr
self.ops = ops
def _getChildren(self):
return self.expr, self.ops
def __repr__(self):
return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
def __init__(self, node, op, expr):
self.node = node
self.op = op
self.expr = expr
self._children = ('augassign', node, op, expr)
class And(Node):
nodes["and"] = "And"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "And(%s)" % (repr(self.nodes),)
def __repr__(self):
return "AugAssign(%s)" % str(self._children[1:])
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):
return self.argnames, self.defaults, self.flags, self.code
def __repr__(self):
return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
class Assign(Node):
nodes['assign'] = 'Assign'
def __init__(self, nodes, expr):
self.nodes = nodes
self.expr = expr
self._children = ('assign', nodes, expr)
def __repr__(self):
return "Assign(%s,%s)" % self._children[1:]
class AssTuple(Node):
nodes['ass_tuple'] = 'AssTuple'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('ass_tuple', nodes)
def __repr__(self):
return "AssTuple(%s)" % self._children[1:]
nodes["assign"] = "Assign"
def __init__(self, nodes, expr):
self.nodes = nodes
self.expr = expr
def _getChildren(self):
return self.nodes, self.expr
def __repr__(self):
return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
class AssList(Node):
nodes['ass_list'] = 'AssList'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('ass_list', nodes)
def __repr__(self):
return "AssList(%s)" % self._children[1:]
class AssName(Node):
nodes['ass_name'] = 'AssName'
def __init__(self, name, flags):
self.name = name
self.flags = flags
self._children = ('ass_name', name, flags)
def __repr__(self):
return "AssName(%s,%s)" % self._children[1:]
class AssAttr(Node):
nodes['ass_attr'] = 'AssAttr'
def __init__(self, expr, attrname, flags):
self.expr = expr
self.attrname = attrname
self.flags = flags
self._children = ('ass_attr', expr, attrname, flags)
def __repr__(self):
return "AssAttr(%s,%s,%s)" % self._children[1:]
class ListComp(Node):
nodes['listcomp'] = 'ListComp'
def __init__(self, expr, quals):
self.expr = expr
self.quals = quals
self._children = ('listcomp', expr, quals)
def __repr__(self):
return "ListComp(%s, %s)" % self._children[1:]
class ListCompFor(Node):
nodes['listcomp_for'] = 'ListCompFor'
# transformer fills in ifs after node is created
def __init__(self, assign, list, ifs):
self.assign = assign
self.list = list
self.ifs = ifs
self._children = ('listcomp_for', assign, list, ifs)
def __repr__(self):
return "ListCompFor(%s, %s, %s)" % self._children[1:]
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 __repr__(self):
return "Sub(%s, %s)" % (repr(self.left), repr(self.right))
class ListCompIf(Node):
nodes['listcomp_if'] = 'ListCompIf'
def __init__(self, test):
self.test = test
self._children = ('listcomp_if', test)
def __repr__(self):
return "ListCompIf(%s)" % self._children[1:]
class List(Node):
nodes['list'] = 'List'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('list', nodes)
def __repr__(self):
return "List(%s)" % self._children[1:]
nodes["listcompif"] = "ListCompIf"
def __init__(self, test):
self.test = test
def _getChildren(self):
return self.test,
def __repr__(self):
return "ListCompIf(%s)" % (repr(self.test),)
class Dict(Node):
nodes['dict'] = 'Dict'
def __init__(self, items):
self.items = items
self._children = ('dict', items)
def __repr__(self):
return "Dict(%s)" % self._children[1:]
class Not(Node):
nodes['not'] = 'Not'
def __init__(self, expr):
self.expr = expr
self._children = ('not', expr)
def __repr__(self):
return "Not(%s)" % self._children[1:]
class Compare(Node):
nodes['compare'] = 'Compare'
def __init__(self, expr, ops):
self.expr = expr
self.ops = ops
self._children = ('compare', expr, ops)
def __repr__(self):
return "Compare(%s,%s)" % self._children[1:]
class Name(Node):
nodes['name'] = 'Name'
def __init__(self, name):
self.name = name
self._children = ('name', name)
def __repr__(self):
return "Name(%s)" % self._children[1:]
class Global(Node):
nodes['global'] = 'Global'
def __init__(self, names):
self.names = names
self._children = ('global', names)
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 __repr__(self):
return "Div(%s, %s)" % (repr(self.left), repr(self.right))
def __repr__(self):
return "Global(%s)" % self._children[1:]
class Discard(Node):
nodes["discard"] = "Discard"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "Discard(%s)" % (repr(self.expr),)
class Backquote(Node):
nodes['backquote'] = 'Backquote'
def __init__(self, node):
self.expr = node
self._children = ('backquote', node)
def __repr__(self):
return "Backquote(%s)" % self._children[1:]
class Getattr(Node):
nodes['getattr'] = 'Getattr'
def __init__(self, expr, attrname):
self.expr = expr
self.attrname = attrname
self._children = ('getattr', expr, attrname)
def __repr__(self):
return "Getattr(%s,%s)" % self._children[1:]
class CallFunc(Node):
nodes['call_func'] = 'CallFunc'
nodes["backquote"] = "Backquote"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "Backquote(%s)" % (repr(self.expr),)
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
self._children = ('call_func', node, args, star_args, dstar_args)
def __repr__(self):
return "CallFunc(%s,%s,*%s, **%s)" % self._children[1:]
class Keyword(Node):
nodes['keyword'] = 'Keyword'
def __init__(self, name, expr):
self.name = name
self.expr = expr
self._children = ('keyword', name, expr)
def __repr__(self):
return "Keyword(%s,%s)" % self._children[1:]
class Subscript(Node):
nodes['subscript'] = 'Subscript'
def __init__(self, expr, flags, subs):
self.expr = expr
self.flags = flags
self.subs = subs
self._children = ('subscript', expr, flags, subs)
def __repr__(self):
return "Subscript(%s,%s,%s)" % self._children[1:]
class Ellipsis(EmptyNode):
nodes['ellipsis'] = 'Ellipsis'
_children = ('ellipsis',)
def __repr__(self):
return "Ellipsis()"
class Sliceobj(Node):
nodes['sliceobj'] = 'Sliceobj'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('sliceobj', nodes)
def __repr__(self):
return "Sliceobj(%s)" % self._children[1:]
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
self._children = ('slice', expr, flags, lower, upper)
def __repr__(self):
return "Slice(%s,%s,%s,%s)" % self._children[1:]
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 __repr__(self):
return "RightShift(%s, %s)" % (repr(self.left), repr(self.right))
class Continue(Node):
nodes["continue"] = "Continue"
def __init__(self, ):
pass
def _getChildren(self):
return ()
def __repr__(self):
return "Continue()"
class Assert(Node):
nodes['assert'] = 'Assert'
class While(Node):
nodes["while"] = "While"
def __init__(self, test, body, else_):
self.test = test
self.body = body
self.else_ = else_
def _getChildren(self):
return self.test, self.body, self.else_
def __repr__(self):
return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
def __init__(self, test, fail):
self.test = test
self.fail = fail
self._children = ('assert', test, fail)
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 __repr__(self):
return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
def __repr__(self):
return "Assert(%s,%s)" % self._children[1:]
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 __repr__(self):
return "LeftShift(%s, %s)" % (repr(self.left), repr(self.right))
class Tuple(Node):
nodes['tuple'] = 'Tuple'
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 __repr__(self):
return "Mul(%s, %s)" % (repr(self.left), repr(self.right))
def __init__(self, nodes):
self.nodes = nodes
self._children = ('tuple', nodes)
class List(Node):
nodes["list"] = "List"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "List(%s)" % (repr(self.nodes),)
def __repr__(self):
return "Tuple(%s)" % self._children[1:]
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 __repr__(self):
return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
class Or(Node):
nodes['or'] = 'Or'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('or', nodes)
nodes["or"] = "Or"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Or(%s)" % (repr(self.nodes),)
def __repr__(self):
return "Or(%s)" % self._children[1:]
class And(Node):
nodes['and'] = 'And'
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 __repr__(self):
return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
def __init__(self, nodes):
self.nodes = nodes
self._children = ('and', 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 __repr__(self):
return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
def __repr__(self):
return "And(%s)" % self._children[1:]
class Const(Node):
nodes["const"] = "Const"
def __init__(self, value):
self.value = value
def _getChildren(self):
return self.value,
def __repr__(self):
return "Const(%s)" % (repr(self.value),)
class Bitor(Node):
nodes['bitor'] = 'Bitor'
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 __repr__(self):
return "Mod(%s, %s)" % (repr(self.left), repr(self.right))
def __init__(self, nodes):
self.nodes = nodes
self._children = ('bitor', nodes)
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):
return self.name, self.bases, self.doc, self.code
def __repr__(self):
return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
def __repr__(self):
return "Bitor(%s)" % self._children[1:]
class Not(Node):
nodes["not"] = "Not"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "Not(%s)" % (repr(self.expr),)
class Bitxor(Node):
nodes['bitxor'] = 'Bitxor'
nodes["bitxor"] = "Bitxor"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Bitxor(%s)" % (repr(self.nodes),)
def __init__(self, nodes):
self.nodes = nodes
self._children = ('bitxor', nodes)
def __repr__(self):
return "Bitxor(%s)" % self._children[1:]
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 __repr__(self):
return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
class Bitand(Node):
nodes['bitand'] = 'Bitand'
nodes["bitand"] = "Bitand"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Bitand(%s)" % (repr(self.nodes),)
class Break(Node):
nodes["break"] = "Break"
def __init__(self, ):
pass
def _getChildren(self):
return ()
def __repr__(self):
return "Break()"
def __init__(self, nodes):
self.nodes = nodes
self._children = ('bitand', nodes)
def __repr__(self):
return "Bitand(%s)" % self._children[1:]
class LeftShift(Node):
nodes['<<'] = 'LeftShift'
class Stmt(Node):
nodes["stmt"] = "Stmt"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Stmt(%s)" % (repr(self.nodes),)
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('<<', (left, right))
class Assert(Node):
nodes["assert"] = "Assert"
def __init__(self, test, fail):
self.test = test
self.fail = fail
def _getChildren(self):
return self.test, self.fail
def __repr__(self):
return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
def __repr__(self):
return "LeftShift(%s)" % self._children[1:]
class Exec(Node):
nodes["exec"] = "Exec"
def __init__(self, expr, locals, globals):
self.expr = expr
self.locals = locals
self.globals = globals
def _getChildren(self):
return self.expr, self.locals, self.globals
def __repr__(self):
return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
class RightShift(Node):
nodes['>>'] = 'RightShift'
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 __repr__(self):
return "Power(%s, %s)" % (repr(self.left), repr(self.right))
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('>>', (left, right))
class Import(Node):
nodes["import"] = "Import"
def __init__(self, names):
self.names = names
def _getChildren(self):
return self.names,
def __repr__(self):
return "Import(%s)" % (repr(self.names),)
def __repr__(self):
return "RightShift(%s)" % self._children[1:]
class Return(Node):
nodes["return"] = "Return"
def __init__(self, value):
self.value = value
def _getChildren(self):
return self.value,
def __repr__(self):
return "Return(%s)" % (repr(self.value),)
class Add(Node):
nodes['+'] = 'Add'
nodes["add"] = "Add"
def __init__(self, (left, right)):
self.left = left
self.right = right
def _getChildren(self):
return self.left, self.right
def __repr__(self):
return "Add(%s, %s)" % (repr(self.left), repr(self.right))
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('+', (left, right))
def __repr__(self):
return "Add(%s)" % self._children[1:]
class Sub(Node):
nodes['-'] = 'Sub'
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('-', (left, right))
def __repr__(self):
return "Sub(%s)" % self._children[1:]
class Mul(Node):
nodes['*'] = 'Mul'
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('*', (left, right))
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 __repr__(self):
return "Mul(%s)" % self._children[1:]
def _getChildren(self):
return self.name, self.argnames, self.defaults, self.flags, self.doc, self.code
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 Div(Node):
nodes['/'] = 'Div'
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('/', (left, right))
class TryExcept(Node):
nodes["tryexcept"] = "TryExcept"
def __init__(self, body, handlers, else_):
self.body = body
self.handlers = handlers
self.else_ = else_
def _getChildren(self):
return self.body, self.handlers, self.else_
def __repr__(self):
return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
def __repr__(self):
return "Div(%s)" % self._children[1:]
class Subscript(Node):
nodes["subscript"] = "Subscript"
def __init__(self, expr, flags, subs):
self.expr = expr
self.flags = flags
self.subs = subs
def _getChildren(self):
return self.expr, self.flags, self.subs
def __repr__(self):
return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs))
class Ellipsis(Node):
nodes["ellipsis"] = "Ellipsis"
def __init__(self, ):
pass
def _getChildren(self):
return ()
def __repr__(self):
return "Ellipsis()"
class Mod(Node):
nodes['%'] = 'Mod'
class Print(Node):
nodes["print"] = "Print"
def __init__(self, nodes, dest):
self.nodes = nodes
self.dest = dest
def _getChildren(self):
return self.nodes, self.dest
def __repr__(self):
return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('%', (left, right))
class UnaryAdd(Node):
nodes["unaryadd"] = "UnaryAdd"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "UnaryAdd(%s)" % (repr(self.expr),)
def __repr__(self):
return "Mod(%s)" % self._children[1:]
class ListCompFor(Node):
nodes["listcompfor"] = "ListCompFor"
def __init__(self, assign, list, ifs):
self.assign = assign
self.list = list
self.ifs = ifs
def _getChildren(self):
return self.assign, self.list, self.ifs
def __repr__(self):
return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
class Power(Node):
nodes['power'] = 'Power'
class Dict(Node):
nodes["dict"] = "Dict"
def __init__(self, items):
self.items = items
def _getChildren(self):
return self.items,
def __repr__(self):
return "Dict(%s)" % (repr(self.items),)
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('power', (left, right))
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 __repr__(self):
return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
def __repr__(self):
return "Power(%s)" % self._children[1:]
class AssList(Node):
nodes["asslist"] = "AssList"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "AssList(%s)" % (repr(self.nodes),)
class UnaryAdd(Node):
nodes['unary+'] = 'UnaryAdd'
class UnarySub(Node):
nodes["unarysub"] = "UnarySub"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "UnarySub(%s)" % (repr(self.expr),)
def __init__(self, node):
self.expr = node
self._children = ('unary+', node)
class Sliceobj(Node):
nodes["sliceobj"] = "Sliceobj"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Sliceobj(%s)" % (repr(self.nodes),)
def __repr__(self):
return "UnaryAdd(%s)" % self._children[1:]
class Invert(Node):
nodes["invert"] = "Invert"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "Invert(%s)" % (repr(self.expr),)
class UnarySub(Node):
nodes['unary-'] = 'UnarySub'
class Name(Node):
nodes["name"] = "Name"
def __init__(self, name):
self.name = name
def _getChildren(self):
return self.name,
def __repr__(self):
return "Name(%s)" % (repr(self.name),)
def __init__(self, node):
self.expr = node
self._children = ('unary-', node)
class AssTuple(Node):
nodes["asstuple"] = "AssTuple"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "AssTuple(%s)" % (repr(self.nodes),)
def __repr__(self):
return "UnarySub(%s)" % self._children[1:]
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):
return self.assign, self.list, self.body, self.else_
def __repr__(self):
return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
class Invert(Node):
nodes['invert'] = 'Invert'
class Raise(Node):
nodes["raise"] = "Raise"
def __init__(self, expr1, expr2, expr3):
self.expr1 = expr1
self.expr2 = expr2
self.expr3 = expr3
def _getChildren(self):
return self.expr1, self.expr2, self.expr3
def __repr__(self):
return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
def __init__(self, node):
self.expr = node
self._children = ('invert', node)
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 __repr__(self):
return "From(%s, %s)" % (repr(self.modname), repr(self.names))
def __repr__(self):
return "Invert(%s)" % self._children[1:]
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):
return self.expr, self.flags, self.lower, self.upper
def __repr__(self):
return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
# now clean up the nodes dictionary
klasses = globals()
for k in nodes.keys():
nodes[k] = klasses[nodes[k]]
# Local Variables:
# mode:python
# indent-tabs-mode: nil
# py-indent-offset: 2
# py-smart-indentation: nil
# End:
nodes[k] = klasses[nodes[k]]
Tools/compiler/compiler/ast.py
Dosyayı görüntüle @ 628d289d
import types
from consts import CO_VARARGS, CO_VARKEYWORDS
"""Python abstract syntax node definitions
nodes = {}
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:
if type(elt) is types.TupleType:
for elt2 in flatten(elt):
l.append(elt2)
elif type(elt) is types.ListType:
for elt2 in flatten(elt):
l.append(elt2)
else:
l.append(elt)
return l
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 asList(nodes):
l = []
for item in nodes:
if hasattr(item, "asList"):
l.append(item.asList())
else:
if type(item) is types.TupleType:
l.append(tuple(asList(item)))
elif type(item) is types.ListType:
l.append(asList(item))
else:
l.append(item)
return l
l = []
for item in nodes:
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:
def __init__(self, *args):
self._children = args
self.lineno = None
def __getitem__(self, index):
return self._children[index]
def __repr__(self):
return "<Node %s>" % self._children[0]
def __len__(self):
return len(self._children)
def __getslice__(self, low, high):
return self._children[low:high]
def getChildren(self):
return tuple(flatten(self._children[1:]))
def getType(self):
return self._children[0]
def asList(self):
return tuple(asList(self._children))
lineno = None
def getType(self):
pass
def getChildren(self):
# XXX It would be better to generate flat values to begin with
return flatten(self._getChildren())
def asList(self):
return tuple(asList(self.getChildren()))
class EmptyNode(Node):
def __init__(self):
self.lineno = None
class Module(Node):
nodes['module'] = 'Module'
def __init__(self, doc, node):
self.doc = doc
self.node = node
self._children = ('module', doc, node)
def __repr__(self):
return "Module(%s,%s)" % self._children[1:]
class Stmt(Node):
nodes['stmt'] = 'Stmt'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('stmt', nodes)
def __repr__(self):
return "Stmt(%s)" % self._children[1:]
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._children = ('function',
name, argnames, defaults, flags, doc, code)
self.varargs = self.kwargs = None
if flags & CO_VARARGS:
self.varargs = 1
if flags & CO_VARKEYWORDS:
self.kwargs = 1
def __repr__(self):
return "Function(%s,%s,%s,%s,%s,%s)" % self._children[1:]
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._children = ('lambda', argnames, defaults, flags, code)
self.varargs = self.kwargs = None
if flags & CO_VARARGS:
self.varargs = 1
if flags & CO_VARKEYWORDS:
self.kwargs = 1
def __repr__(self):
return "Lambda(%s,%s,%s,%s)" % self._children[1:]
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
self._children = ('class', name, bases, doc, code)
def __repr__(self):
return "Class(%s,%s,%s,%s)" % self._children[1:]
class Pass(EmptyNode):
nodes['pass'] = 'Pass'
_children = ('pass',)
def __repr__(self):
return "Pass()"
class Break(EmptyNode):
nodes['break'] = 'Break'
_children = ('break',)
def __repr__(self):
return "Break()"
class Continue(EmptyNode):
nodes['continue'] = 'Continue'
_children = ('continue',)
def __repr__(self):
return "Continue()"
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_
self._children = ('for', assign, list, body, else_)
def __repr__(self):
return "For(%s,%s,%s,%s)" % self._children[1:]
class While(Node):
nodes['while'] = 'While'
def __init__(self, test, body, else_):
self.test = test
self.body = body
self.else_ = else_
self._children = ('while', test, body, else_)
def __repr__(self):
return "While(%s,%s,%s)" % self._children[1:]
def __init__(self):
self.lineno = None
class If(Node):
"""if: [ (testNode, suiteNode), ...], elseNode"""
nodes['if'] = 'If'
def __init__(self, tests, else_):
self.tests = tests
self.else_ = else_
self._children = ('if', tests, else_)
def __repr__(self):
return "If(%s,%s)" % self._children[1:]
class Exec(Node):
nodes['exec'] = 'Exec'
def __init__(self, expr, locals, globals):
self.expr = expr
self.locals = locals
self.globals = globals
self._children = ('exec', expr, locals, globals)
def __repr__(self):
return "Exec(%s,%s,%s)" % self._children[1:]
class From(Node):
nodes['from'] = 'From'
def __init__(self, modname, names):
self.modname = modname
self.names = names
self._children = ('from', modname, names)
def __repr__(self):
return "From(%s,%s)" % self._children[1:]
class Import(Node):
nodes['import'] = 'Import'
def __init__(self, names):
self.names = names
self._children = ('import', names)
def __repr__(self):
return "Import(%s)" % self._children[1:]
class Raise(Node):
nodes['raise'] = 'Raise'
def __init__(self, expr1, expr2, expr3):
self.expr1 = expr1
self.expr2 = expr2
self.expr3 = expr3
self._children = ('raise', expr1, expr2, expr3)
def __repr__(self):
return "Raise(%s,%s,%s)" % self._children[1:]
class TryFinally(Node):
nodes['tryfinally'] = 'TryFinally'
def __init__(self, body, final):
self.body = body
self.final = final
self._children = ('tryfinally', body, final)
def __repr__(self):
return "TryFinally(%s,%s)" % self._children[1:]
class TryExcept(Node):
"""Try/Except body and handlers
The handlers attribute is a sequence of tuples. The elements of the
tuple are the exception name, the name to bind the exception to, and
the body of the except clause.
"""
nodes['tryexcept'] = 'TryExcept'
def __init__(self, body, handlers, else_):
self.body = body
self.handlers = handlers
self.else_ = else_
self._children = ('tryexcept', body, handlers, else_)
def __repr__(self):
return "TryExcept(%s,%s,%s)" % self._children[1:]
nodes["if"] = "If"
def __init__(self, tests, else_):
self.tests = tests
self.else_ = else_
def _getChildren(self):
return self.tests, self.else_
def __repr__(self):
return "If(%s, %s)" % (repr(self.tests), repr(self.else_))
class Return(Node):
nodes['return'] = 'Return'
def __init__(self, value):
self.value = value
self._children = ('return', value)
def __repr__(self):
return "Return(%s)" % self._children[1:]
class Const(Node):
nodes['const'] = 'Const'
def __init__(self, value):
self.value = value
self._children = ('const', value)
class ListComp(Node):
nodes["listcomp"] = "ListComp"
def __init__(self, expr, quals):
self.expr = expr
self.quals = quals
def _getChildren(self):
return self.expr, self.quals
def __repr__(self):
return "ListComp(%s, %s)" % (repr(self.expr), repr(self.quals))
def __repr__(self):
return "Const(%s)" % self._children[1:]
class Bitor(Node):
nodes["bitor"] = "Bitor"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Bitor(%s)" % (repr(self.nodes),)
class Pass(Node):
nodes["pass"] = "Pass"
def __init__(self, ):
pass
def _getChildren(self):
return ()
def __repr__(self):
return "Pass()"
class Print(Node):
nodes['print'] = 'Print'
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 __repr__(self):
return "Module(%s, %s)" % (repr(self.doc), repr(self.node))
def __init__(self, nodes, dest):
self.nodes = nodes
self.dest = dest
self._children = ('print', nodes, dest)
class Global(Node):
nodes["global"] = "Global"
def __init__(self, names):
self.names = names
def _getChildren(self):
return self.names,
def __repr__(self):
return "Global(%s)" % (repr(self.names),)
def __repr__(self):
return "Print(%s, %s)" % (self._children[1:-1], self._children[-1])
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):
return self.node, self.args, self.star_args, self.dstar_args
def __repr__(self):
return "CallFunc(%s, %s, %s, %s)" % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
class Printnl(Node):
nodes['printnl'] = 'Printnl'
def __init__(self, nodes, dest):
self.nodes = nodes
self.dest = dest
self._children = ('printnl', nodes, dest)
def __repr__(self):
return "Printnl(%s, %s)" % (self._children[1:-1], self._children[-1])
nodes["printnl"] = "Printnl"
def __init__(self, nodes, dest):
self.nodes = nodes
self.dest = dest
def _getChildren(self):
return self.nodes, self.dest
def __repr__(self):
return "Printnl(%s, %s)" % (repr(self.nodes), repr(self.dest))
class Discard(Node):
nodes['discard'] = 'Discard'
def __init__(self, expr):
self.expr = expr
self._children = ('discard', expr)
def __repr__(self):
return "Discard(%s)" % self._children[1:]
class Tuple(Node):
nodes["tuple"] = "Tuple"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Tuple(%s)" % (repr(self.nodes),)
class AugAssign(Node):
nodes['augassign'] = 'AugAssign'
class Compare(Node):
nodes["compare"] = "Compare"
def __init__(self, expr, ops):
self.expr = expr
self.ops = ops
def _getChildren(self):
return self.expr, self.ops
def __repr__(self):
return "Compare(%s, %s)" % (repr(self.expr), repr(self.ops))
def __init__(self, node, op, expr):
self.node = node
self.op = op
self.expr = expr
self._children = ('augassign', node, op, expr)
class And(Node):
nodes["and"] = "And"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "And(%s)" % (repr(self.nodes),)
def __repr__(self):
return "AugAssign(%s)" % str(self._children[1:])
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):
return self.argnames, self.defaults, self.flags, self.code
def __repr__(self):
return "Lambda(%s, %s, %s, %s)" % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
class Assign(Node):
nodes['assign'] = 'Assign'
def __init__(self, nodes, expr):
self.nodes = nodes
self.expr = expr
self._children = ('assign', nodes, expr)
def __repr__(self):
return "Assign(%s,%s)" % self._children[1:]
class AssTuple(Node):
nodes['ass_tuple'] = 'AssTuple'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('ass_tuple', nodes)
def __repr__(self):
return "AssTuple(%s)" % self._children[1:]
nodes["assign"] = "Assign"
def __init__(self, nodes, expr):
self.nodes = nodes
self.expr = expr
def _getChildren(self):
return self.nodes, self.expr
def __repr__(self):
return "Assign(%s, %s)" % (repr(self.nodes), repr(self.expr))
class AssList(Node):
nodes['ass_list'] = 'AssList'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('ass_list', nodes)
def __repr__(self):
return "AssList(%s)" % self._children[1:]
class AssName(Node):
nodes['ass_name'] = 'AssName'
def __init__(self, name, flags):
self.name = name
self.flags = flags
self._children = ('ass_name', name, flags)
def __repr__(self):
return "AssName(%s,%s)" % self._children[1:]
class AssAttr(Node):
nodes['ass_attr'] = 'AssAttr'
def __init__(self, expr, attrname, flags):
self.expr = expr
self.attrname = attrname
self.flags = flags
self._children = ('ass_attr', expr, attrname, flags)
def __repr__(self):
return "AssAttr(%s,%s,%s)" % self._children[1:]
class ListComp(Node):
nodes['listcomp'] = 'ListComp'
def __init__(self, expr, quals):
self.expr = expr
self.quals = quals
self._children = ('listcomp', expr, quals)
def __repr__(self):
return "ListComp(%s, %s)" % self._children[1:]
class ListCompFor(Node):
nodes['listcomp_for'] = 'ListCompFor'
# transformer fills in ifs after node is created
def __init__(self, assign, list, ifs):
self.assign = assign
self.list = list
self.ifs = ifs
self._children = ('listcomp_for', assign, list, ifs)
def __repr__(self):
return "ListCompFor(%s, %s, %s)" % self._children[1:]
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 __repr__(self):
return "Sub(%s, %s)" % (repr(self.left), repr(self.right))
class ListCompIf(Node):
nodes['listcomp_if'] = 'ListCompIf'
def __init__(self, test):
self.test = test
self._children = ('listcomp_if', test)
def __repr__(self):
return "ListCompIf(%s)" % self._children[1:]
class List(Node):
nodes['list'] = 'List'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('list', nodes)
def __repr__(self):
return "List(%s)" % self._children[1:]
nodes["listcompif"] = "ListCompIf"
def __init__(self, test):
self.test = test
def _getChildren(self):
return self.test,
def __repr__(self):
return "ListCompIf(%s)" % (repr(self.test),)
class Dict(Node):
nodes['dict'] = 'Dict'
def __init__(self, items):
self.items = items
self._children = ('dict', items)
def __repr__(self):
return "Dict(%s)" % self._children[1:]
class Not(Node):
nodes['not'] = 'Not'
def __init__(self, expr):
self.expr = expr
self._children = ('not', expr)
def __repr__(self):
return "Not(%s)" % self._children[1:]
class Compare(Node):
nodes['compare'] = 'Compare'
def __init__(self, expr, ops):
self.expr = expr
self.ops = ops
self._children = ('compare', expr, ops)
def __repr__(self):
return "Compare(%s,%s)" % self._children[1:]
class Name(Node):
nodes['name'] = 'Name'
def __init__(self, name):
self.name = name
self._children = ('name', name)
def __repr__(self):
return "Name(%s)" % self._children[1:]
class Global(Node):
nodes['global'] = 'Global'
def __init__(self, names):
self.names = names
self._children = ('global', names)
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 __repr__(self):
return "Div(%s, %s)" % (repr(self.left), repr(self.right))
def __repr__(self):
return "Global(%s)" % self._children[1:]
class Discard(Node):
nodes["discard"] = "Discard"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "Discard(%s)" % (repr(self.expr),)
class Backquote(Node):
nodes['backquote'] = 'Backquote'
def __init__(self, node):
self.expr = node
self._children = ('backquote', node)
def __repr__(self):
return "Backquote(%s)" % self._children[1:]
class Getattr(Node):
nodes['getattr'] = 'Getattr'
def __init__(self, expr, attrname):
self.expr = expr
self.attrname = attrname
self._children = ('getattr', expr, attrname)
def __repr__(self):
return "Getattr(%s,%s)" % self._children[1:]
class CallFunc(Node):
nodes['call_func'] = 'CallFunc'
nodes["backquote"] = "Backquote"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "Backquote(%s)" % (repr(self.expr),)
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
self._children = ('call_func', node, args, star_args, dstar_args)
def __repr__(self):
return "CallFunc(%s,%s,*%s, **%s)" % self._children[1:]
class Keyword(Node):
nodes['keyword'] = 'Keyword'
def __init__(self, name, expr):
self.name = name
self.expr = expr
self._children = ('keyword', name, expr)
def __repr__(self):
return "Keyword(%s,%s)" % self._children[1:]
class Subscript(Node):
nodes['subscript'] = 'Subscript'
def __init__(self, expr, flags, subs):
self.expr = expr
self.flags = flags
self.subs = subs
self._children = ('subscript', expr, flags, subs)
def __repr__(self):
return "Subscript(%s,%s,%s)" % self._children[1:]
class Ellipsis(EmptyNode):
nodes['ellipsis'] = 'Ellipsis'
_children = ('ellipsis',)
def __repr__(self):
return "Ellipsis()"
class Sliceobj(Node):
nodes['sliceobj'] = 'Sliceobj'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('sliceobj', nodes)
def __repr__(self):
return "Sliceobj(%s)" % self._children[1:]
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
self._children = ('slice', expr, flags, lower, upper)
def __repr__(self):
return "Slice(%s,%s,%s,%s)" % self._children[1:]
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 __repr__(self):
return "RightShift(%s, %s)" % (repr(self.left), repr(self.right))
class Continue(Node):
nodes["continue"] = "Continue"
def __init__(self, ):
pass
def _getChildren(self):
return ()
def __repr__(self):
return "Continue()"
class Assert(Node):
nodes['assert'] = 'Assert'
class While(Node):
nodes["while"] = "While"
def __init__(self, test, body, else_):
self.test = test
self.body = body
self.else_ = else_
def _getChildren(self):
return self.test, self.body, self.else_
def __repr__(self):
return "While(%s, %s, %s)" % (repr(self.test), repr(self.body), repr(self.else_))
def __init__(self, test, fail):
self.test = test
self.fail = fail
self._children = ('assert', test, fail)
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 __repr__(self):
return "AssName(%s, %s)" % (repr(self.name), repr(self.flags))
def __repr__(self):
return "Assert(%s,%s)" % self._children[1:]
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 __repr__(self):
return "LeftShift(%s, %s)" % (repr(self.left), repr(self.right))
class Tuple(Node):
nodes['tuple'] = 'Tuple'
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 __repr__(self):
return "Mul(%s, %s)" % (repr(self.left), repr(self.right))
def __init__(self, nodes):
self.nodes = nodes
self._children = ('tuple', nodes)
class List(Node):
nodes["list"] = "List"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "List(%s)" % (repr(self.nodes),)
def __repr__(self):
return "Tuple(%s)" % self._children[1:]
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 __repr__(self):
return "AugAssign(%s, %s, %s)" % (repr(self.node), repr(self.op), repr(self.expr))
class Or(Node):
nodes['or'] = 'Or'
def __init__(self, nodes):
self.nodes = nodes
self._children = ('or', nodes)
nodes["or"] = "Or"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Or(%s)" % (repr(self.nodes),)
def __repr__(self):
return "Or(%s)" % self._children[1:]
class And(Node):
nodes['and'] = 'And'
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 __repr__(self):
return "Keyword(%s, %s)" % (repr(self.name), repr(self.expr))
def __init__(self, nodes):
self.nodes = nodes
self._children = ('and', 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 __repr__(self):
return "AssAttr(%s, %s, %s)" % (repr(self.expr), repr(self.attrname), repr(self.flags))
def __repr__(self):
return "And(%s)" % self._children[1:]
class Const(Node):
nodes["const"] = "Const"
def __init__(self, value):
self.value = value
def _getChildren(self):
return self.value,
def __repr__(self):
return "Const(%s)" % (repr(self.value),)
class Bitor(Node):
nodes['bitor'] = 'Bitor'
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 __repr__(self):
return "Mod(%s, %s)" % (repr(self.left), repr(self.right))
def __init__(self, nodes):
self.nodes = nodes
self._children = ('bitor', nodes)
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):
return self.name, self.bases, self.doc, self.code
def __repr__(self):
return "Class(%s, %s, %s, %s)" % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
def __repr__(self):
return "Bitor(%s)" % self._children[1:]
class Not(Node):
nodes["not"] = "Not"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "Not(%s)" % (repr(self.expr),)
class Bitxor(Node):
nodes['bitxor'] = 'Bitxor'
nodes["bitxor"] = "Bitxor"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Bitxor(%s)" % (repr(self.nodes),)
def __init__(self, nodes):
self.nodes = nodes
self._children = ('bitxor', nodes)
def __repr__(self):
return "Bitxor(%s)" % self._children[1:]
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 __repr__(self):
return "TryFinally(%s, %s)" % (repr(self.body), repr(self.final))
class Bitand(Node):
nodes['bitand'] = 'Bitand'
nodes["bitand"] = "Bitand"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Bitand(%s)" % (repr(self.nodes),)
class Break(Node):
nodes["break"] = "Break"
def __init__(self, ):
pass
def _getChildren(self):
return ()
def __repr__(self):
return "Break()"
def __init__(self, nodes):
self.nodes = nodes
self._children = ('bitand', nodes)
def __repr__(self):
return "Bitand(%s)" % self._children[1:]
class LeftShift(Node):
nodes['<<'] = 'LeftShift'
class Stmt(Node):
nodes["stmt"] = "Stmt"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Stmt(%s)" % (repr(self.nodes),)
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('<<', (left, right))
class Assert(Node):
nodes["assert"] = "Assert"
def __init__(self, test, fail):
self.test = test
self.fail = fail
def _getChildren(self):
return self.test, self.fail
def __repr__(self):
return "Assert(%s, %s)" % (repr(self.test), repr(self.fail))
def __repr__(self):
return "LeftShift(%s)" % self._children[1:]
class Exec(Node):
nodes["exec"] = "Exec"
def __init__(self, expr, locals, globals):
self.expr = expr
self.locals = locals
self.globals = globals
def _getChildren(self):
return self.expr, self.locals, self.globals
def __repr__(self):
return "Exec(%s, %s, %s)" % (repr(self.expr), repr(self.locals), repr(self.globals))
class RightShift(Node):
nodes['>>'] = 'RightShift'
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 __repr__(self):
return "Power(%s, %s)" % (repr(self.left), repr(self.right))
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('>>', (left, right))
class Import(Node):
nodes["import"] = "Import"
def __init__(self, names):
self.names = names
def _getChildren(self):
return self.names,
def __repr__(self):
return "Import(%s)" % (repr(self.names),)
def __repr__(self):
return "RightShift(%s)" % self._children[1:]
class Return(Node):
nodes["return"] = "Return"
def __init__(self, value):
self.value = value
def _getChildren(self):
return self.value,
def __repr__(self):
return "Return(%s)" % (repr(self.value),)
class Add(Node):
nodes['+'] = 'Add'
nodes["add"] = "Add"
def __init__(self, (left, right)):
self.left = left
self.right = right
def _getChildren(self):
return self.left, self.right
def __repr__(self):
return "Add(%s, %s)" % (repr(self.left), repr(self.right))
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('+', (left, right))
def __repr__(self):
return "Add(%s)" % self._children[1:]
class Sub(Node):
nodes['-'] = 'Sub'
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('-', (left, right))
def __repr__(self):
return "Sub(%s)" % self._children[1:]
class Mul(Node):
nodes['*'] = 'Mul'
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('*', (left, right))
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 __repr__(self):
return "Mul(%s)" % self._children[1:]
def _getChildren(self):
return self.name, self.argnames, self.defaults, self.flags, self.doc, self.code
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 Div(Node):
nodes['/'] = 'Div'
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('/', (left, right))
class TryExcept(Node):
nodes["tryexcept"] = "TryExcept"
def __init__(self, body, handlers, else_):
self.body = body
self.handlers = handlers
self.else_ = else_
def _getChildren(self):
return self.body, self.handlers, self.else_
def __repr__(self):
return "TryExcept(%s, %s, %s)" % (repr(self.body), repr(self.handlers), repr(self.else_))
def __repr__(self):
return "Div(%s)" % self._children[1:]
class Subscript(Node):
nodes["subscript"] = "Subscript"
def __init__(self, expr, flags, subs):
self.expr = expr
self.flags = flags
self.subs = subs
def _getChildren(self):
return self.expr, self.flags, self.subs
def __repr__(self):
return "Subscript(%s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.subs))
class Ellipsis(Node):
nodes["ellipsis"] = "Ellipsis"
def __init__(self, ):
pass
def _getChildren(self):
return ()
def __repr__(self):
return "Ellipsis()"
class Mod(Node):
nodes['%'] = 'Mod'
class Print(Node):
nodes["print"] = "Print"
def __init__(self, nodes, dest):
self.nodes = nodes
self.dest = dest
def _getChildren(self):
return self.nodes, self.dest
def __repr__(self):
return "Print(%s, %s)" % (repr(self.nodes), repr(self.dest))
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('%', (left, right))
class UnaryAdd(Node):
nodes["unaryadd"] = "UnaryAdd"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "UnaryAdd(%s)" % (repr(self.expr),)
def __repr__(self):
return "Mod(%s)" % self._children[1:]
class ListCompFor(Node):
nodes["listcompfor"] = "ListCompFor"
def __init__(self, assign, list, ifs):
self.assign = assign
self.list = list
self.ifs = ifs
def _getChildren(self):
return self.assign, self.list, self.ifs
def __repr__(self):
return "ListCompFor(%s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.ifs))
class Power(Node):
nodes['power'] = 'Power'
class Dict(Node):
nodes["dict"] = "Dict"
def __init__(self, items):
self.items = items
def _getChildren(self):
return self.items,
def __repr__(self):
return "Dict(%s)" % (repr(self.items),)
def __init__(self, (left, right)):
self.left = left
self.right = right
self._children = ('power', (left, right))
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 __repr__(self):
return "Getattr(%s, %s)" % (repr(self.expr), repr(self.attrname))
def __repr__(self):
return "Power(%s)" % self._children[1:]
class AssList(Node):
nodes["asslist"] = "AssList"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "AssList(%s)" % (repr(self.nodes),)
class UnaryAdd(Node):
nodes['unary+'] = 'UnaryAdd'
class UnarySub(Node):
nodes["unarysub"] = "UnarySub"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "UnarySub(%s)" % (repr(self.expr),)
def __init__(self, node):
self.expr = node
self._children = ('unary+', node)
class Sliceobj(Node):
nodes["sliceobj"] = "Sliceobj"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "Sliceobj(%s)" % (repr(self.nodes),)
def __repr__(self):
return "UnaryAdd(%s)" % self._children[1:]
class Invert(Node):
nodes["invert"] = "Invert"
def __init__(self, expr):
self.expr = expr
def _getChildren(self):
return self.expr,
def __repr__(self):
return "Invert(%s)" % (repr(self.expr),)
class UnarySub(Node):
nodes['unary-'] = 'UnarySub'
class Name(Node):
nodes["name"] = "Name"
def __init__(self, name):
self.name = name
def _getChildren(self):
return self.name,
def __repr__(self):
return "Name(%s)" % (repr(self.name),)
def __init__(self, node):
self.expr = node
self._children = ('unary-', node)
class AssTuple(Node):
nodes["asstuple"] = "AssTuple"
def __init__(self, nodes):
self.nodes = nodes
def _getChildren(self):
return self.nodes,
def __repr__(self):
return "AssTuple(%s)" % (repr(self.nodes),)
def __repr__(self):
return "UnarySub(%s)" % self._children[1:]
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):
return self.assign, self.list, self.body, self.else_
def __repr__(self):
return "For(%s, %s, %s, %s)" % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
class Invert(Node):
nodes['invert'] = 'Invert'
class Raise(Node):
nodes["raise"] = "Raise"
def __init__(self, expr1, expr2, expr3):
self.expr1 = expr1
self.expr2 = expr2
self.expr3 = expr3
def _getChildren(self):
return self.expr1, self.expr2, self.expr3
def __repr__(self):
return "Raise(%s, %s, %s)" % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
def __init__(self, node):
self.expr = node
self._children = ('invert', node)
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 __repr__(self):
return "From(%s, %s)" % (repr(self.modname), repr(self.names))
def __repr__(self):
return "Invert(%s)" % self._children[1:]
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):
return self.expr, self.flags, self.lower, self.upper
def __repr__(self):
return "Slice(%s, %s, %s, %s)" % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
# now clean up the nodes dictionary
klasses = globals()
for k in nodes.keys():
nodes[k] = klasses[nodes[k]]
# Local Variables:
# mode:python
# indent-tabs-mode: nil
# py-indent-offset: 2
# py-smart-indentation: nil
# End:
nodes[k] = klasses[nodes[k]]
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment