def __init__(self, frame, anchor, target, src1, src2):
self.frame = frame
self.anchor = anchor
self.target = target
self.types1 = CompoundTypeNode()
self.types2 = CompoundTypeNode()
CompoundTypeNode.__init__(self)
src1.connect(self.recv1)
src2.connect(self.recv2)
return
def __init__(self, parent, expt):
self.received = set()
self.reraise = False
self.var = CompoundTypeNode()
if expt:
self.expt = CompoundTypeNode()
expt.connect(self.recv_expt)
else:
self.expt = None
ExecutionFrame.__init__(self, parent, None)
return
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 process_args_nokwd(self, frame, anchor, args):
checker = TypeChecker(frame, [NumberType.get_typeobj()], 'arg 0')
args[0].connect(checker.recv)
checker = TypeChecker(frame, [NumberType.get_typeobj()], 'arg 1')
args[1].connect(checker.recv)
obj = CompoundTypeNode(args)
return TupleType.create_tuple([obj, obj])
def __init__(self, typeobj, elemall=None):
self.elemall = CompoundTypeNode()
if elemall:
elemall.connect(self.elemall.recv)
self.iter = None
BuiltinAggregateObject.__init__(self, typeobj)
return
def __init__(self, frame, anchor, tupobj, nelements, strict=True):
self.tupobj = tupobj
self.elements = [CompoundTypeNode() for _ in xrange(nelements)]
self.strict = strict
self.received = set()
ExpressionNode.__init__(self, frame, anchor)
self.tupobj.connect(self.recv_tupobj)
return
def process_args_nokwd(self, frame, anchor, args):
checker = TypeChecker(frame, [NumberType.get_typeobj()], 'arg 0')
args[0].connect(checker.recv)
checker = TypeChecker(frame, [NumberType.get_typeobj()], 'arg 1')
args[1].connect(checker.recv)
if 3 <= len(args):
checker = TypeChecker(frame, [NumberType.get_typeobj()], 'arg 2')
args[2].connect(checker.recv)
return CompoundTypeNode(args)
def __init__(self, typeobj, elemall=None, elements=None):
IterObject.__init__(self, typeobj, elemall=elemall)
self.sent = CompoundTypeNode()
if elements:
for obj in elements:
if isinstance(obj, GeneratorSlot):
self.sent.connect(obj.received.recv)
obj.connect(self.elemall.recv)
return
def call(self, frame, anchor, args, kwargs):
if kwargs:
frame.raise_expt(ErrorConfig.NoKeywordArgs())
return UndefinedTypeNode.get_object()
elems = [CompoundTypeNode() for arg1 in args]
zipelem = TupleType.create_tuple(elements=elems)
seq = ListType.create_list(elemall=zipelem)
for (i, arg1) in enumerate(args):
IterElement(frame, anchor, arg1).connect(elems[i].recv)
return seq
def __init__(self, name, bases):
self.name = name
self.bases = bases
self.attrs = {}
self.boundmethods = {}
self.frames = set()
BuiltinType.__init__(self)
self.klasses = CompoundTypeNode(bases+[self])
self.instance = InstanceObject(self)
return
def __init__(self, frame, anchor, seq, initial):
self.frame = frame
self.anchor = anchor
self.received = set()
self.elem = IterElement(frame, anchor, seq)
self.result = CompoundTypeNode()
if initial:
initial.connect(self.result.recv)
else:
self.elem.connect(self.result.recv)
CompoundTypeNode.__init__(self, [self.result])
IterElement(frame, anchor, seq).connect(self.recv_elem)
return
def call(self, frame, anchor, args, kwargs):
if kwargs:
frame.raise_expt(ErrorConfig.NoKeywordArgs())
return UndefinedTypeNode.get_object()
retobj = CompoundTypeNode()
if len(args) == 1:
IterElement(frame, anchor, args[0]).connect(retobj.recv)
else:
for arg1 in args:
arg1.connect(retobj.recv)
if 'key' in kwargs:
IterFuncChecker(frame, anchor, retobj, kwargs['key'])
return retobj
def __init__(self, frame, anchor, target, fcmp, fkey):
self.frame = frame
self.anchor = anchor
self.target = target
self.received_fkey = set()
self.received_fcmp = set()
self.key = CompoundTypeNode()
CompoundTypeNode.__init__(self)
if fkey:
fkey.connect(self.recv_fkey)
else:
target.elemall.connect(self.key.recv)
if fcmp:
fcmp.connect(self.recv_fcmp)
return
def __init__(self, dictobj, name):
self.dictobj = dictobj
self.found = CompoundTypeNode([dictobj.value])
BuiltinConstMethod.__init__(self, name, self.found, [ANY], [ANY])
return
def __init__(self, value):
self.received = CompoundTypeNode()
CompoundTypeNode.__init__(self, [value])
return
def __init__(self, typeobj, elements=None, elemall=None):
self.elements = elements
if elements != None:
elemall = CompoundTypeNode(elements)
BuiltinSequenceObject.__init__(self, typeobj, elemall)
return
