def create_attr(self, frame, anchor, name):
if name == 'append':
return self.SequenceAppender('list.append', self, args=[ANY])
elif name == 'count':
return BuiltinConstMethod('list.count', IntType.get_object(),
[ANY])
elif name == 'extend':
return self.SequenceExtender('list.extend', self, args=[ANY])
elif name == 'index':
return BuiltinConstMethod(
'list.index',
IntType.get_object(), [ANY], [IntType, IntType],
expts=[ErrorConfig.MaybeElementNotFound()])
elif name == 'insert':
return self.InsertMethod('list.insert', self, [IntType, ANY])
elif name == 'pop':
return BuiltinConstMethod(
'list.pop',
self.elemall, [], [IntType],
expts=[ErrorConfig.MaybeElementNotRemovable()])
elif name == 'remove':
return BuiltinConstMethod(
'list.remove',
NoneType.get_object(), [ANY],
expts=[ErrorConfig.MaybeElementNotRemovable()])
elif name == 'reverse':
return BuiltinConstMethod('list.remove', NoneType.get_object())
elif name == 'sort':
return self.SortMethod('list.sort', self)
raise NodeAttrError(name)
def process_args(self, frame, anchor, args, kwargs):
if 2 <= len(args):
args[1].connect(self.dictobj.value.recv)
else:
NoneType.get_object().connect(self.dictobj.value.recv)
v = args[0]
if v not in self.cache_fromkeys:
converter = DictObject.DictConverterFromKeys(frame, anchor, self.dictobj)
self.cache_fromkeys[v] = converter
v.connect(converter.recv)
return self.dictobj
def process_args(self, frame, anchor, args, kwargs):
if 2 <= len(args):
args[1].connect(self.dictobj.value.recv)
else:
NoneType.get_object().connect(self.dictobj.value.recv)
v = args[0]
if v not in self.cache_fromkeys:
converter = DictObject.DictConverterFromKeys(
frame, anchor, self.dictobj)
self.cache_fromkeys[v] = converter
v.connect(converter.recv)
return self.dictobj
def create_attr(self, frame, anchor, name):
if name == 'send':
return self.Send('generator.send', self, self.elemall, [ANY],
expts=[StopIterationType.maybe('might raise StopIteration')])
if name == 'next':
NoneType.get_object().connect(self.sent.recv)
return self.Send('generator.next', self, self.elemall,
expts=[StopIterationType.maybe('might raise StopIteration')])
if name == 'throw':
# XXX do nothing for now
return BuiltinConstMethod('generator.throw', NoneType.get_object(), [ANY], [ANY, ANY])
if name == 'close':
return self.Send('generator.close', self, NoneType.get_object(), [ANY])
return IterObject.create_attr(self, frame, anchor, name)
def process_args(self, frame, anchor, args, kwargs):
v = args[0]
if v not in self.cache_update:
converter = DictObject.DictConverterFromKeys(frame, anchor, self.dictobj)
self.cache_update[v] = converter
v.connect(converter.recv)
return NoneType.get_object()
def process_args(self, frame, anchor, args, kwargs):
v = args[0]
if v not in self.cache_update:
converter = DictObject.DictConverterFromKeys(
frame, anchor, self.dictobj)
self.cache_update[v] = converter
v.connect(converter.recv)
return NoneType.get_object()
def create_attr(self, frame, anchor, name):
if name == 'add':
return self.SequenceAppender('set.add', self, args=[ANY])
elif name == 'clear':
return BuiltinConstMethod('set.clear', NoneType.get_object())
elif name == 'difference_update':
return BuiltinConstMethod('set.difference_update',
NoneType.get_object(), [[ANY]])
elif name == 'discard':
return BuiltinConstMethod('set.discard', NoneType.get_object(),
[ANY])
elif name == 'intersection_update':
return BuiltinConstMethod('set.intersection_update',
NoneType.get_object(), [[ANY]])
elif name == 'pop':
return BuiltinConstMethod(
'set.pop',
NoneType.get_object(),
expts=[ErrorConfig.MaybeElementNotRemovable()])
elif name == 'remove':
return BuiltinConstMethod(
'set.remove',
NoneType.get_object(), [ANY],
expts=[ErrorConfig.MaybeElementNotFound()])
elif name == 'symmetric_difference_update':
return self.SequenceExtender('set.symmetric_difference_update',
self,
args=[ANY])
elif name == 'update':
return self.SequenceExtender('set.update', self, self, [ANY])
return FrozenSetObject.create_attr(self, frame, anchor, name)
def __init__(self, typeobj, items=None, key=None, value=None):
if items != None:
assert key == None and value == None
self.key = CompoundTypeNode( k for (k,v) in items )
self.value = CompoundTypeNode( v for (k,v) in items )
else:
self.key = CompoundTypeNode(key)
self.value = CompoundTypeNode(value)
self.default = CompoundTypeNode([NoneType.get_object()])
self.value.connect(self.default.recv)
self.iter = None
BuiltinAggregateObject.__init__(self, typeobj)
return
def __init__(self,
name,
target,
retobj=NoneType.get_object(),
args=None,
expts=None):
self.target = target
BuiltinConstMethod.__init__(self,
name,
retobj,
args=args,
expts=expts)
return
def create_attr(self, frame, anchor, name):
if name == 'send':
return self.Send(
'generator.send',
self,
self.elemall, [ANY],
expts=[StopIterationType.maybe('might raise StopIteration')])
if name == 'next':
NoneType.get_object().connect(self.sent.recv)
return self.Send(
'generator.next',
self,
self.elemall,
expts=[StopIterationType.maybe('might raise StopIteration')])
if name == 'throw':
# XXX do nothing for now
return BuiltinConstMethod('generator.throw', NoneType.get_object(),
[ANY], [ANY, ANY])
if name == 'close':
return self.Send('generator.close', self, NoneType.get_object(),
[ANY])
return IterObject.create_attr(self, frame, anchor, name)
def __init__(self, typeobj, items=None, key=None, value=None):
if items != None:
assert key == None and value == None
self.key = CompoundTypeNode(k for (k, v) in items)
self.value = CompoundTypeNode(v for (k, v) in items)
else:
self.key = CompoundTypeNode(key)
self.value = CompoundTypeNode(value)
self.default = CompoundTypeNode([NoneType.get_object()])
self.value.connect(self.default.recv)
self.iter = None
BuiltinAggregateObject.__init__(self, typeobj)
return
def __init__(self,
name,
target,
retobj=NoneType.get_object(),
args=None,
optargs=None):
self.target = target
self.cache_extend = {}
BuiltinConstMethod.__init__(self,
name,
retobj,
args=args,
optargs=optargs)
return
def create_attr(self, frame, anchor, name):
if name == 'append':
return self.SequenceAppender('list.append', self, args=[ANY])
elif name == 'count':
return BuiltinConstMethod('list.count', IntType.get_object(), [ANY])
elif name == 'extend':
return self.SequenceExtender('list.extend', self, args=[ANY])
elif name == 'index':
return BuiltinConstMethod('list.index', IntType.get_object(), [ANY], [IntType, IntType],
expts=[ErrorConfig.MaybeElementNotFound()])
elif name == 'insert':
return self.InsertMethod('list.insert', self, [IntType, ANY])
elif name == 'pop':
return BuiltinConstMethod('list.pop', self.elemall, [], [IntType],
expts=[ErrorConfig.MaybeElementNotRemovable()])
elif name == 'remove':
return BuiltinConstMethod('list.remove', NoneType.get_object(), [ANY],
expts=[ErrorConfig.MaybeElementNotRemovable()])
elif name == 'reverse':
return BuiltinConstMethod('list.remove', NoneType.get_object())
elif name == 'sort':
return self.SortMethod('list.sort', self)
raise NodeAttrError(name)
def create_attr(self, frame, anchor, name):
if name == 'clear':
return BuiltinConstMethod('dict.clear', NoneType.get_object())
elif name == 'copy':
dictobj = self.get_type().create_copy(frame, anchor, self)
return BuiltinConstMethod('dict.copy', dictobj)
elif name == 'fromkeys':
return DictType.FromKeys('dict.fromkeys')
elif name == 'get':
return DictObject.Get(self, 'dict.get')
elif name == 'has_key':
return BuiltinConstMethod('dict.has_key', BoolType.get_object(),
[ANY])
elif name == 'keys':
return BuiltinConstMethod('dict.keys',
ListType.create_list(self.key))
elif name == 'values':
return BuiltinConstMethod('dict.values',
ListType.create_list(self.value))
elif name == 'items':
return BuiltinConstMethod(
'dict.items',
ListType.create_list(
TupleType.create_tuple([self.key, self.value])))
elif name == 'iterkeys':
return BuiltinConstMethod('dict.iterkeys',
IterType.create_iter(self.key))
elif name == 'itervalues':
return BuiltinConstMethod('dict.itervalues',
IterType.create_iter(self.value))
elif name == 'iteritems':
return BuiltinConstMethod(
'dict.iteritems',
IterType.create_iter(
TupleType.create_tuple([self.key, self.value])))
elif name == 'pop':
return DictObject.Pop(self, 'dict.pop')
elif name == 'popitem':
return BuiltinConstMethod(
'dict.popitem',
TupleType.create_tuple([self.key, self.value]),
expts=[ErrorConfig.MaybeElementNotFound()])
elif name == 'setdefault':
return DictObject.SetDefault(self, 'dict.setdefault')
elif name == 'update':
return DictObject.Update(self, 'dict.update')
raise NodeAttrError(name)
def process_args(self, frame, anchor, args, kwargs):
params = dict.fromkeys(['cmp', 'key', 'reverse'])
args = list(args)
if args:
params['cmp'] = args.pop(0)
if args:
params['key'] = args.pop(0)
if args:
params['reserved'] = args.pop(0)
for (k,v) in kwargs.iteritems():
if k in params:
if params[k] != None:
frame.raise_expt(ErrorConfig.NoKeywordArg1(k))
else:
params[k] = v
else:
frame.raise_expt(ErrorConfig.NoKeywordArg1(k))
self.FuncChecker(frame, anchor, self.target, params['cmp'], params['key'])
return NoneType.get_object()
def process_args(self, frame, anchor, args, kwargs):
params = dict.fromkeys(['cmp', 'key', 'reverse'])
args = list(args)
if args:
params['cmp'] = args.pop(0)
if args:
params['key'] = args.pop(0)
if args:
params['reserved'] = args.pop(0)
for (k, v) in kwargs.iteritems():
if k in params:
if params[k] != None:
frame.raise_expt(ErrorConfig.NoKeywordArg1(k))
else:
params[k] = v
else:
frame.raise_expt(ErrorConfig.NoKeywordArg1(k))
self.FuncChecker(frame, anchor, self.target, params['cmp'],
params['key'])
return NoneType.get_object()
def create_attr(self, frame, anchor, name):
if name == 'clear':
return BuiltinConstMethod('dict.clear', NoneType.get_object())
elif name == 'copy':
dictobj = self.get_type().create_copy(frame, anchor, self)
return BuiltinConstMethod('dict.copy', dictobj)
elif name == 'fromkeys':
return DictType.FromKeys('dict.fromkeys')
elif name == 'get':
return DictObject.Get(self, 'dict.get')
elif name == 'has_key':
return BuiltinConstMethod('dict.has_key', BoolType.get_object(), [ANY])
elif name == 'keys':
return BuiltinConstMethod('dict.keys',
ListType.create_list(self.key))
elif name == 'values':
return BuiltinConstMethod('dict.values',
ListType.create_list(self.value))
elif name == 'items':
return BuiltinConstMethod('dict.items',
ListType.create_list(TupleType.create_tuple([self.key, self.value])))
elif name == 'iterkeys':
return BuiltinConstMethod('dict.iterkeys',
IterType.create_iter(self.key))
elif name == 'itervalues':
return BuiltinConstMethod('dict.itervalues',
IterType.create_iter(self.value))
elif name == 'iteritems':
return BuiltinConstMethod('dict.iteritems',
IterType.create_iter(TupleType.create_tuple([self.key, self.value])))
elif name == 'pop':
return DictObject.Pop(self, 'dict.pop')
elif name == 'popitem':
return BuiltinConstMethod('dict.popitem', TupleType.create_tuple([self.key, self.value]),
expts=[ErrorConfig.MaybeElementNotFound()])
elif name == 'setdefault':
return DictObject.SetDefault(self, 'dict.setdefault')
elif name == 'update':
return DictObject.Update(self, 'dict.update')
raise NodeAttrError(name)
def create_attr(self, frame, anchor, name):
if name == 'add':
return self.SequenceAppender('set.add', self, args=[ANY])
elif name == 'clear':
return BuiltinConstMethod('set.clear', NoneType.get_object())
elif name == 'difference_update':
return BuiltinConstMethod('set.difference_update', NoneType.get_object(), [[ANY]])
elif name == 'discard':
return BuiltinConstMethod('set.discard', NoneType.get_object(), [ANY])
elif name == 'intersection_update':
return BuiltinConstMethod('set.intersection_update', NoneType.get_object(), [[ANY]])
elif name == 'pop':
return BuiltinConstMethod('set.pop', NoneType.get_object(),
expts=[ErrorConfig.MaybeElementNotRemovable()])
elif name == 'remove':
return BuiltinConstMethod('set.remove', NoneType.get_object(), [ANY],
expts=[ErrorConfig.MaybeElementNotFound()])
elif name == 'symmetric_difference_update':
return self.SequenceExtender('set.symmetric_difference_update', self, args=[ANY])
elif name == 'update':
return self.SequenceExtender('set.update', self, self, [ANY])
return FrozenSetObject.create_attr(self, frame, anchor, name)
def __init__(self, name, target): self.target = target BuiltinConstMethod.__init__(self, name, NoneType.get_object(), [], [ANY,ANY,ANY]) return
def __init__(self, dictobj, name):
self.cache_update = {}
self.dictobj = dictobj
BuiltinConstMethod.__init__(self, name, NoneType.get_object(),
[ANY])
return
def process_args(self, frame, anchor, args, kwargs):
if len(args) == 1:
self.found.update_type(NoneType.get_object())
return BuiltinConstMethod.process_args(self, frame, anchor, args,
kwargs)
def __init__(self, name, target, retobj=NoneType.get_object(), args=None, expts=None): self.target = target BuiltinConstMethod.__init__(self, name, retobj, args=args, expts=expts) return
def __init__(self, name, target, retobj=NoneType.get_object(), args=None, optargs=None):
self.target = target
self.cache_extend = {}
BuiltinConstMethod.__init__(self, name, retobj, args=args, optargs=optargs)
return
def process_args(self, frame, anchor, args, kwargs):
if len(args) == 1:
self.found.update_type(NoneType.get_object())
return BuiltinConstMethod.process_args(self, frame, anchor, args, kwargs)
def __init__(self, name, target):
self.target = target
BuiltinConstMethod.__init__(self, name, NoneType.get_object(), [],
[ANY, ANY, ANY])
return
def __init__(self, dictobj, name):
self.cache_update = {}
self.dictobj = dictobj
BuiltinConstMethod.__init__(self, name, NoneType.get_object(), [ANY])
return
def build_stmt(reporter, frame, space, tree, evals, isfuncdef=False, parent_space=None):
from pyntch.basic_types import NoneType, StrType
from pyntch.module import ModuleNotFound
from pyntch.config import ErrorConfig
assert isinstance(frame, ExecutionFrame)
if isinstance(tree, ast.Module):
build_stmt(reporter, frame, space, tree.node, evals)
# def
elif isinstance(tree, ast.Function):
name = tree.name
defaults = [ build_expr(reporter, frame, space, value, evals) for value in tree.defaults ]
parent_space = parent_space or space # class definition
func = FuncType(reporter, frame, parent_space, tree, name, tree.argnames,
defaults, tree.varargs, tree.kwargs, tree)
if tree.decorators:
for node in tree.decorators:
decor = build_expr(reporter, frame, space, node, evals)
func = FunCall(ExecutionFrame(frame, node), node, decor, (func,))
space[name].bind(func)
# class
elif isinstance(tree, ast.Class):
name = tree.name
bases = [ build_expr(reporter, frame, space, base, evals) for base in tree.bases ]
klass = PythonClassType(reporter, frame, space, tree, name, bases, evals, tree)
space[name].bind(klass)
# assign
elif isinstance(tree, ast.Assign):
for n in tree.nodes:
value = build_expr(reporter, frame, space, tree.expr, evals)
build_assign(reporter, frame, space, n, value, evals)
# augassign
elif isinstance(tree, ast.AugAssign):
left = build_expr(reporter, frame, space, tree.node, evals)
if isinstance(left, UndefinedTypeNode):
# ignore an undefined variable.
pass
else:
right = build_expr(reporter, frame, space, tree.expr, evals)
value = AssignOp(ExecutionFrame(frame, tree), tree, tree.op, left, right)
build_assign(reporter, frame, space, tree.node, value, evals)
# return
elif isinstance(tree, ast.Return):
value = build_expr(reporter, frame, space, tree.value, evals)
evals.append(('r', value))
return True
# yield (for python 2.4)
elif isinstance(tree, ast.Yield):
value = build_expr(reporter, frame, space, tree.value, evals)
evals.append(('y', value))
return True
# (mutliple statements)
elif isinstance(tree, ast.Stmt):
stmt = None
exit = False
for stmt in tree.nodes:
exit = build_stmt(reporter, frame, space, stmt, evals, parent_space=parent_space)
if isfuncdef and not exit:
# if the last statement is not a Return or Raise
value = NoneType.get_object()
evals.append(('r', value))
return exit
# if, elif, else
elif isinstance(tree, ast.If):
for (expr,stmt) in tree.tests:
value = build_expr(reporter, frame, space, expr, evals)
exit = build_stmt(reporter, frame, space, stmt, evals)
if tree.else_:
exit = build_stmt(reporter, frame, space, tree.else_, evals) and exit
else:
exit = False
return exit
# for
elif isinstance(tree, ast.For):
seq = build_expr(reporter, frame, space, tree.list, evals)
elem = IterElement(ExecutionFrame(frame, tree.list), tree.list, seq)
build_assign(reporter, frame, space, tree.assign, elem, evals)
exit = build_stmt(reporter, frame, space, tree.body, evals)
if tree.else_:
exit = build_stmt(reporter, frame, space, tree.else_, evals) and exit
return exit
# while
elif isinstance(tree, ast.While):
value = build_expr(reporter, frame, space, tree.test, evals)
exit = build_stmt(reporter, frame, space, tree.body, evals)
if tree.else_:
exit = build_stmt(reporter, frame, space, tree.else_, evals) and exit
return exit
# try ... except
elif isinstance(tree, ast.TryExcept):
catcher = ExceptionCatcher(frame)
for (expr,e,stmt) in tree.handlers:
if expr:
expts = build_expr(reporter, frame, space, expr, evals)
handler = catcher.add_handler(expts)
if e:
build_assign(reporter, handler, space, e, handler.var, evals)
else:
handler = catcher.add_handler(None)
exit = build_stmt(reporter, handler, space, stmt, evals)
exit = build_stmt(reporter, catcher, space, tree.body, evals) and exit
if tree.else_:
exit = build_stmt(reporter, frame, space, tree.else_, evals) and exit
return exit
# try ... finally
elif isinstance(tree, ast.TryFinally):
exit = build_stmt(reporter, frame, space, tree.body, evals)
exit = build_stmt(reporter, frame, space, tree.final, evals) and exit
return exit
# raise
elif isinstance(tree, ast.Raise):
# XXX ignoring tree.expr3 (what is this for anyway?)
if tree.expr2:
expttype = build_expr(reporter, frame, space, tree.expr1, evals)
exptarg = build_expr(reporter, frame, space, tree.expr2, evals)
ExceptionMaker(ExecutionFrame(frame, tree), tree, expttype, (exptarg,))
elif tree.expr1:
expttype = build_expr(reporter, frame, space, tree.expr1, evals)
ExceptionMaker(ExecutionFrame(frame, tree), tree, expttype, ())
else:
# re-raise
frame.set_reraise()
return True
# printnl
elif isinstance(tree, (ast.Print, ast.Printnl)):
for node in tree.nodes:
value = build_expr(reporter, frame, space, node, evals)
StrType.StrConverter(ExecutionFrame(frame, node), tree, value)
# discard
elif isinstance(tree, ast.Discard):
value = build_expr(reporter, frame, space, tree.expr, evals)
# pass, break, continue
elif isinstance(tree, (ast.Pass, ast.Break, ast.Continue)):
pass
# import
elif isinstance(tree, ast.Import):
for (name,asname) in tree.names:
try:
modules = tree._module.load_module(name)
if asname:
space[asname].bind(modules[-1])
else:
asname = name.split('.')[0]
space[asname].bind(modules[0])
except ModuleNotFound, e:
ErrorConfig.module_not_found(e.name)
def is_ignored(klass, obj): from pyntch.basic_types import NoneType return klass.ignore_none and obj.is_type(NoneType.get_typeobj())
def call(self, frame, anchor, args, kwargs): from pyntch.basic_types import NoneType return NoneType.get_object()
