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 recv(self, src):
for obj in src:
if obj.is_type(TupleType.get_typeobj()):
obj.connect(self.tuplechecker.recv)
else:
obj.connect(self.checker.recv)
return
def recv(self, src):
for obj in src:
if obj.is_type(TupleType.get_typeobj()):
obj.connect(self.tuplechecker.recv)
else:
obj.connect(self.checker.recv)
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 recv_expt(self, src):
from pyntch.aggregate_types import TupleType
for obj in src:
if obj in self.received: continue
self.received.add(obj)
if obj.is_type(TupleType.get_typeobj()):
obj.elemall.connect(self.expt.recv)
else:
obj.connect(self.expt.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 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 call(self, frame, anchor, args, kwargs):
from pyntch.basic_types import StrType
from pyntch.aggregate_types import DictType, TupleType
from pyntch.expression import TupleUnpack, TupleSlice
# Process keyword arguments first.
varsleft = list(self.argvars)
varikwargs = []
for (kwname, kwvalue) in kwargs.iteritems():
for var1 in varsleft:
if isinstance(var1, Variable) and var1.name == kwname:
var1.bind(kwvalue)
# When a keyword argument is given, remove that name from the remaining arguments.
varsleft.remove(var1)
break
else:
if self.kwarg:
varikwargs.append(kwvalue)
else:
frame.raise_expt(ErrorConfig.InvalidKeywordArgs(kwname))
# Process standard arguments.
variargs = []
for arg1 in args:
assert arg1 != None, args
if varsleft:
var1 = varsleft.pop(0)
assign_arg(frame, anchor, var1, arg1)
elif self.variarg:
variargs.append(arg1)
else:
# Too many arguments.
frame.raise_expt(
ErrorConfig.InvalidNumOfArgs(len(self.argvars), len(args)))
if len(self.defaults) < len(varsleft):
# Too few arguments.
frame.raise_expt(
ErrorConfig.InvalidNumOfArgs(len(self.argvars), len(args)))
# Handle remaining arguments: kwargs and variargs.
if self.variarg and variargs:
self.space[self.variarg].bind(TupleType.create_tuple(variargs))
if self.kwarg:
if varikwargs:
self.space[self.kwarg].bind(
DictType.create_dict(key=StrType.get_object(),
value=varikwargs))
else:
self.space[self.kwarg].bind(DictType.create_null(
frame, anchor))
# Remember where this is called from.
self.frames.add(frame)
# Propagate the exceptions upward.
self.frame.connect(frame.recv)
return self.body
def recv_tuple(self, src):
from pyntch.aggregate_types import TupleType
for obj in src:
if obj in self.received_tuple: continue
self.received_tuple.add(obj)
if obj.is_type(TupleType.get_typeobj()):
if obj.elements:
self.varargs.add(tuple(obj.elements))
else:
self.varargs.add((obj.elemall, ))
else:
self.varargs.add((IterElement(self.frame, self.anchor, obj), ))
self.recv_func(None)
return
def recv_tuple(self, src):
from pyntch.aggregate_types import TupleType
for obj in src:
if obj in self.received_tuple: continue
self.received_tuple.add(obj)
if obj.is_type(TupleType.get_typeobj()):
if obj.elements:
self.varargs.add(tuple(obj.elements))
else:
self.varargs.add((obj.elemall,))
else:
self.varargs.add((IterElement(self.frame, self.anchor, obj),))
self.recv_func(None)
return
def call(self, frame, anchor, args, kwargs):
from pyntch.basic_types import StrType
from pyntch.aggregate_types import DictType, TupleType
from pyntch.expression import TupleUnpack, TupleSlice
# Process keyword arguments first.
varsleft = list(self.argvars)
varikwargs = []
for (kwname, kwvalue) in kwargs.iteritems():
for var1 in varsleft:
if isinstance(var1, Variable) and var1.name == kwname:
var1.bind(kwvalue)
# When a keyword argument is given, remove that name from the remaining arguments.
varsleft.remove(var1)
break
else:
if self.kwarg:
varikwargs.append(kwvalue)
else:
frame.raise_expt(ErrorConfig.InvalidKeywordArgs(kwname))
# Process standard arguments.
variargs = []
for arg1 in args:
assert arg1 != None, args
if varsleft:
var1 = varsleft.pop(0)
assign_arg(frame, anchor, var1, arg1)
elif self.variarg:
variargs.append(arg1)
else:
# Too many arguments.
frame.raise_expt(ErrorConfig.InvalidNumOfArgs(len(self.argvars), len(args)))
if len(self.defaults) < len(varsleft):
# Too few arguments.
frame.raise_expt(ErrorConfig.InvalidNumOfArgs(len(self.argvars), len(args)))
# Handle remaining arguments: kwargs and variargs.
if self.variarg and variargs:
self.space[self.variarg].bind(TupleType.create_tuple(variargs))
if self.kwarg:
if varikwargs:
self.space[self.kwarg].bind(DictType.create_dict(key=StrType.get_object(), value=varikwargs))
else:
self.space[self.kwarg].bind(DictType.create_null(frame, anchor))
# Remember where this is called from.
self.frames.add(frame)
# Propagate the exceptions upward.
self.frame.connect(frame.recv)
return self.body
def recv_tupobj(self, src):
from pyntch.aggregate_types import TupleType
for obj in src:
if obj in self.received: continue
self.received.add(obj)
if obj.is_type(TupleType.get_typeobj()) and obj.elements != None:
# Unpack a fixed-length tuple.
if (self.strict and len(obj.elements) != len(self.elements)) or len(obj.elements) < len(self.elements):
self.raise_expt(ErrorConfig.NotUnpackable(obj))
else:
for (src,dest) in zip(obj.elements, self.elements):
src.connect(dest.recv)
else:
# Unpack a variable-length tuple or other iterable.
elemall = IterElement(self.frame, self.anchor, obj)
for dest in self.elements:
elemall.connect(dest.recv)
return
def recv_tupobj(self, src):
from pyntch.aggregate_types import TupleType
for obj in src:
if obj in self.received: continue
self.received.add(obj)
if obj.is_type(TupleType.get_typeobj()) and obj.elements != None:
# Unpack a fixed-length tuple.
if (self.strict and len(obj.elements) != len(self.elements)
) or len(obj.elements) < len(self.elements):
self.raise_expt(ErrorConfig.NotUnpackable(obj))
else:
for (src, dest) in zip(obj.elements, self.elements):
src.connect(dest.recv)
else:
# Unpack a variable-length tuple or other iterable.
elemall = IterElement(self.frame, self.anchor, obj)
for dest in self.elements:
elemall.connect(dest.recv)
return
def recv_tupobj(self, src):
from pyntch.aggregate_types import TupleType
for obj in src:
if obj in self.received: continue
self.received.add(obj)
if obj.is_type(TupleType.get_typeobj()) and obj.elements != None:
# Unpack a fixed-length tuple.
if self.length:
if self.length != len(obj.elements):
self.raise_expt(ErrorConfig.NotUnpackable(obj))
else:
for i in xrange(self.length):
obj.elements[self.start+i].connect(self.recv)
else:
for i in xrange(self.start, len(obj.elements)):
obj.elements[i].connect(self.recv)
else:
# Unpack a variable-length tuple or other iterable.
IterElement(self.frame, self.anchor, obj).connect(self.recv)
return
def recv_tupobj(self, src):
from pyntch.aggregate_types import TupleType
for obj in src:
if obj in self.received: continue
self.received.add(obj)
if obj.is_type(TupleType.get_typeobj()) and obj.elements != None:
# Unpack a fixed-length tuple.
if self.length:
if self.length != len(obj.elements):
self.raise_expt(ErrorConfig.NotUnpackable(obj))
else:
for i in xrange(self.length):
obj.elements[self.start + i].connect(self.recv)
else:
for i in xrange(self.start, len(obj.elements)):
obj.elements[i].connect(self.recv)
else:
# Unpack a variable-length tuple or other iterable.
IterElement(self.frame, self.anchor, obj).connect(self.recv)
return
def build_expr(reporter, frame, space, tree, evals):
from pyntch.basic_types import BUILTIN_OBJECT, IntType
from pyntch.aggregate_types import IterType, GeneratorType, ListType, SetType, DictType, TupleType
if isinstance(tree, ast.Const):
typename = type(tree.value).__name__
expr = BUILTIN_OBJECT[typename]
elif isinstance(tree, ast.Name):
try:
expr = space[tree.name]
except KeyError:
ExecutionFrame(frame, tree).raise_expt(ErrorConfig.NameUndefined(tree.name))
expr = UndefinedTypeNode(tree.name)
elif isinstance(tree, ast.CallFunc):
func = build_expr(reporter, frame, space, tree.node, evals)
args = tuple( build_expr(reporter, frame, space, arg1, evals)
for arg1 in tree.args if not isinstance(arg1, ast.Keyword) )
kwargs = dict( (arg1.name, build_expr(reporter, frame, space, arg1.expr, evals))
for arg1 in tree.args if isinstance(arg1, ast.Keyword) )
star = dstar = None
if tree.star_args:
star = build_expr(reporter, frame, space, tree.star_args, evals)
if tree.dstar_args:
dstar = build_expr(reporter, frame, space, tree.dstar_args, evals)
expr = FunCall(ExecutionFrame(frame, tree), tree, func, args, kwargs, star, dstar)
elif isinstance(tree, ast.Getattr):
obj = build_expr(reporter, frame, space, tree.expr, evals)
expr = AttrRef(ExecutionFrame(frame, tree), tree, obj, tree.attrname)
elif isinstance(tree, ast.Subscript):
obj = build_expr(reporter, frame, space, tree.expr, evals)
subs = [ build_expr(reporter, frame, space, sub, evals) for sub in tree.subs ]
if len(subs) == 1:
expr = SubRef(ExecutionFrame(frame, tree), tree, obj, subs[0])
else:
expr = SliceRef(ExecutionFrame(frame, tree), tree, obj, subs)
elif isinstance(tree, ast.Slice):
obj = build_expr(reporter, frame, space, tree.expr, evals)
lower = upper = IntType.get_object() # maxint is given when omitted.
if tree.lower:
lower = build_expr(reporter, frame, space, tree.lower, evals)
if tree.upper:
upper = build_expr(reporter, frame, space, tree.upper, evals)
assert lower != None and upper != None
expr = SliceRef(ExecutionFrame(frame, tree), tree, obj, [lower, upper])
elif isinstance(tree, ast.Sliceobj):
elements = [ build_expr(reporter, frame, space, node, evals) for node in tree.nodes ]
expr = SliceObject(ExecutionFrame(frame, tree), tree, elements)
elif isinstance(tree, ast.Tuple):
elements = [ build_expr(reporter, frame, space, node, evals) for node in tree.nodes ]
expr = TupleType.create_tuple(elements)
elif isinstance(tree, ast.List):
elements = [ build_expr(reporter, frame, space, node, evals) for node in tree.nodes ]
expr = ListType.create_list(CompoundTypeNode(elements))
elif isinstance(tree, ast.Set):
elements = [ build_expr(reporter, frame, space, node, evals) for node in tree.nodes ]
expr = SetType.create_set(CompoundTypeNode(elements))
elif isinstance(tree, ast.Dict):
items = [ (build_expr(reporter, frame, space, k, evals),
build_expr(reporter, frame, space, v, evals))
for (k,v) in tree.items ]
expr = DictType.create_dict(items)
# +, -, *, /, %, //, **, <<, >>
elif isinstance(tree, (ast.Add, ast.Sub, ast.Mul, ast.Div,
ast.Mod, ast.FloorDiv, ast.Power,
ast.LeftShift, ast.RightShift)):
op = tree.__class__.__name__
left = build_expr(reporter, frame, space, tree.left, evals)
right = build_expr(reporter, frame, space, tree.right, evals)
expr = BinaryOp(ExecutionFrame(frame, tree), tree, op, left, right)
# &, |, ^
elif isinstance(tree, (ast.Bitand, ast.Bitor, ast.Bitxor)):
op = tree.__class__.__name__
nodes = [ build_expr(reporter, frame, space, node, evals) for node in tree.nodes ]
expr = nodes.pop(0)
for right in nodes:
expr = BinaryOp(ExecutionFrame(frame, tree), tree, op, expr, right)
# ==, !=, <=, >=, <, >, in, not in, is, is not
elif isinstance(tree, ast.Compare):
left = build_expr(reporter, frame, space, tree.expr, evals)
for (op,node) in tree.ops:
right = build_expr(reporter, frame, space, node, evals)
expr = CompareOp(ExecutionFrame(frame, tree), tree, op, left, right)
left = right
# +,-,~
elif isinstance(tree, (ast.UnaryAdd, ast.UnarySub, ast.Invert)):
op = tree.__class__.__name__
value = build_expr(reporter, frame, space, tree.expr, evals)
expr = UnaryOp(ExecutionFrame(frame, tree), tree, op, value)
# and, or
elif isinstance(tree, (ast.And, ast.Or)):
op = tree.__class__.__name__
nodes = [ build_expr(reporter, frame, space, node, evals) for node in tree.nodes ]
expr = BooleanOp(ExecutionFrame(frame, tree), tree, op, nodes)
# not
elif isinstance(tree, ast.Not):
value = build_expr(reporter, frame, space, tree.expr, evals)
expr = NotOp(ExecutionFrame(frame, tree), tree, value)
# lambda
elif isinstance(tree, ast.Lambda):
defaults = [ build_expr(reporter, frame, space, value, evals) for value in tree.defaults ]
expr = LambdaFuncType(reporter, frame, space, tree, tree.argnames,
defaults, tree.varargs, tree.kwargs, tree)
# list comprehension
elif isinstance(tree, ast.ListComp):
elements = [ build_expr(reporter, frame, space, tree.expr, evals) ]
expr = ListType.create_list(CompoundTypeNode(elements))
for qual in tree.quals:
seq = build_expr(reporter, frame, space, qual.list, evals)
elem = IterElement(ExecutionFrame(frame, qual.list), qual.list, seq)
build_assign(reporter, frame, space, qual.assign, elem, evals)
for qif in qual.ifs:
build_expr(reporter, frame, space, qif.test, evals)
# generator expression
elif isinstance(tree, ast.GenExpr):
gen = tree.code
elements = [ build_expr(reporter, frame, space, gen.expr, evals) ]
expr = IterType.create_iter(CompoundTypeNode(elements))
for qual in gen.quals:
seq = build_expr(reporter, frame, space, qual.iter, evals)
elem = IterElement(ExecutionFrame(frame, qual.iter), qual.iter, seq)
build_assign(reporter, frame, space, qual.assign, elem, evals)
for qif in qual.ifs:
build_expr(reporter, frame, space, qif.test, evals)
# yield (for python 2.5)
elif isinstance(tree, ast.Yield):
value = build_expr(reporter, frame, space, tree.value, evals)
slot = GeneratorType.create_slot(value)
evals.append(('y', slot))
expr = slot.received
# ifexp
elif isinstance(tree, ast.IfExp):
test = build_expr(reporter, frame, space, tree.test, evals)
then = build_expr(reporter, frame, space, tree.then, evals)
else_ = build_expr(reporter, frame, space, tree.else_, evals)
expr = IfExpOp(ExecutionFrame(frame, tree), tree, test, then, else_)
# Backquote (unsupported)
elif isinstance(tree, ast.Backquote):
ExecutionFrame(frame, tree).raise_expt(ErrorConfig.NotSupported('backquote notation'))
expr = UndefinedTypeNode('backquote')
# Ellipsis
elif isinstance(tree, ast.Ellipsis):
ExecutionFrame(frame, tree).raise_expt(ErrorConfig.NotSupported('ellipsis'))
expr = UndefinedTypeNode('ellipsis')
else:
# unsupported AST.
raise SyntaxError('unsupported syntax: %r (%s:%r)' % (tree, tree._module.get_path(), tree.lineno))
assert isinstance(expr, (TypeNode, tuple)), expr
evals.append((None, expr))
return expr
def get_attr(self, frame, anchor, name, write=False):
from pyntch.aggregate_types import TupleType, ListType
if write: raise NodeAssignError(name)
if name == 'capitalize':
return BuiltinConstMethod('str.capitalize', self.get_object())
elif name == 'center':
return BuiltinConstMethod('str.center', self.get_object(),
[IntType], [BaseStringType])
elif name == 'count':
return BuiltinConstMethod('str.count', IntType.get_object(),
[BaseStringType], [IntType, IntType])
elif name == 'decode':
return BuiltinConstMethod('str.decode', UnicodeType.get_object(),
[], [BaseStringType, BaseStringType],
[ErrorConfig.MaybeNotDecodable()])
elif name == 'encode':
return BuiltinConstMethod('str.encode', StrType.get_object(), [],
[BaseStringType, BaseStringType],
[ErrorConfig.MaybeNotEncodable()])
elif name == 'endswith':
return BuiltinConstMethod('str.endswith', BoolType.get_object(),
[BaseStringType], [IntType, IntType])
elif name == 'expandtabs':
return BuiltinConstMethod('str.expandtabs', self.get_object(), [],
[IntType])
elif name == 'find':
return BuiltinConstMethod('str.find', IntType.get_object(),
[BaseStringType], [IntType, IntType])
elif name == 'index':
return BuiltinConstMethod('str.index', IntType.get_object(),
[BaseStringType], [IntType, IntType],
[ErrorConfig.MaybeSubstringNotFound()])
elif name == 'isalnum':
return BuiltinConstMethod('str.isalnum', BoolType.get_object())
elif name == 'isalpha':
return BuiltinConstMethod('str.isalpha', BoolType.get_object())
elif name == 'isdigit':
return BuiltinConstMethod('str.isdigit', BoolType.get_object())
elif name == 'islower':
return BuiltinConstMethod('str.islower', BoolType.get_object())
elif name == 'isspace':
return BuiltinConstMethod('str.isspace', BoolType.get_object())
elif name == 'istitle':
return BuiltinConstMethod('str.istitle', BoolType.get_object())
elif name == 'isupper':
return BuiltinConstMethod('str.isupper', BoolType.get_object())
elif name == 'join':
return BuiltinConstMethod('str.join', self.get_object(),
[[BaseStringType]])
elif name == 'ljust':
return BuiltinConstMethod('str.ljust', self.get_object(),
[IntType], [BaseStringType])
elif name == 'lower':
return BuiltinConstMethod('str.lower', self.get_object())
elif name == 'lstrip':
return BuiltinConstMethod('str.lstrip', self.get_object(), [],
[BaseStringType])
elif name == 'partition':
return BuiltinConstMethod(
'str.partiion',
TupleType.create_tuple(
[self.get_object(),
self.get_object(),
self.get_object()]), [BaseStringType])
elif name == 'replace':
return BuiltinConstMethod('str.replace', self.get_object(),
[BaseStringType, BaseStringType],
[IntType])
elif name == 'rfind':
return BuiltinConstMethod('str.rfind', IntType.get_object(),
[BaseStringType], [IntType, IntType])
elif name == 'rindex':
return BuiltinConstMethod('str.rindex', IntType.get_object(),
[BaseStringType], [IntType, IntType],
[ErrorConfig.MaybeSubstringNotFound()])
elif name == 'rjust':
return BuiltinConstMethod('str.rjust', self.get_object(),
[IntType], [BaseStringType])
elif name == 'rpartition':
return BuiltinConstMethod(
'str.rpartiion',
TupleType.create_tuple(
[self.get_object(),
self.get_object(),
self.get_object()]), [BaseStringType])
elif name == 'rsplit':
return BuiltinConstMethod('str.rsplit',
ListType.create_list(self.get_object()),
[], [BaseStringType, IntType])
elif name == 'rstrip':
return BuiltinConstMethod('str.rstrip', self.get_object(), [],
[BaseStringType])
elif name == 'split':
return BuiltinConstMethod('str.split',
ListType.create_list(self.get_object()),
[], [BaseStringType, IntType])
elif name == 'splitlines':
return BuiltinConstMethod('str.splitlines',
ListType.create_list(self.get_object()),
[], [ANY])
elif name == 'startswith':
return BuiltinConstMethod('str.startswith', BoolType.get_object(),
[BaseStringType], [IntType, IntType])
elif name == 'strip':
return BuiltinConstMethod('str.strip', self.get_object(), [],
[BaseStringType])
elif name == 'swapcase':
return BuiltinConstMethod('str.swapcase', self.get_object())
elif name == 'title':
return BuiltinConstMethod('str.title', self.get_object())
elif name == 'upper':
return BuiltinConstMethod('str.upper', self.get_object())
elif name == 'zfill':
return BuiltinConstMethod('str.zfill', self.get_object(),
[IntType])
raise NodeAttrError(name)
def get_attr(self, frame, anchor, name, write=False):
from pyntch.aggregate_types import TupleType, ListType
if write: raise NodeAssignError(name)
if name == 'capitalize':
return BuiltinConstMethod('str.capitalize', self.get_object())
elif name == 'center':
return BuiltinConstMethod('str.center', self.get_object(),
[IntType], [BaseStringType])
elif name == 'count':
return BuiltinConstMethod('str.count', IntType.get_object(),
[BaseStringType], [IntType, IntType])
elif name == 'decode':
return BuiltinConstMethod('str.decode', UnicodeType.get_object(),
[], [BaseStringType, BaseStringType],
[ErrorConfig.MaybeNotDecodable()])
elif name == 'encode':
return BuiltinConstMethod('str.encode', StrType.get_object(),
[], [BaseStringType, BaseStringType],
[ErrorConfig.MaybeNotEncodable()])
elif name == 'endswith':
return BuiltinConstMethod('str.endswith', BoolType.get_object(),
[BaseStringType], [IntType, IntType])
elif name == 'expandtabs':
return BuiltinConstMethod('str.expandtabs', self.get_object(),
[], [IntType])
elif name == 'find':
return BuiltinConstMethod('str.find', IntType.get_object(),
[BaseStringType], [IntType, IntType])
elif name == 'index':
return BuiltinConstMethod('str.index', IntType.get_object(),
[BaseStringType], [IntType, IntType],
[ErrorConfig.MaybeSubstringNotFound()])
elif name == 'isalnum':
return BuiltinConstMethod('str.isalnum', BoolType.get_object())
elif name == 'isalpha':
return BuiltinConstMethod('str.isalpha', BoolType.get_object())
elif name == 'isdigit':
return BuiltinConstMethod('str.isdigit', BoolType.get_object())
elif name == 'islower':
return BuiltinConstMethod('str.islower', BoolType.get_object())
elif name == 'isspace':
return BuiltinConstMethod('str.isspace', BoolType.get_object())
elif name == 'istitle':
return BuiltinConstMethod('str.istitle', BoolType.get_object())
elif name == 'isupper':
return BuiltinConstMethod('str.isupper', BoolType.get_object())
elif name == 'join':
return BuiltinConstMethod('str.join', self.get_object(),
[[BaseStringType]])
elif name == 'ljust':
return BuiltinConstMethod('str.ljust', self.get_object(),
[IntType], [BaseStringType])
elif name == 'lower':
return BuiltinConstMethod('str.lower', self.get_object())
elif name == 'lstrip':
return BuiltinConstMethod('str.lstrip', self.get_object(),
[], [BaseStringType])
elif name == 'partition':
return BuiltinConstMethod('str.partiion',
TupleType.create_tuple([self.get_object(), self.get_object(), self.get_object()]),
[BaseStringType])
elif name == 'replace':
return BuiltinConstMethod('str.replace', self.get_object(),
[BaseStringType, BaseStringType], [IntType])
elif name == 'rfind':
return BuiltinConstMethod('str.rfind', IntType.get_object(),
[BaseStringType], [IntType, IntType])
elif name == 'rindex':
return BuiltinConstMethod('str.rindex', IntType.get_object(),
[BaseStringType], [IntType, IntType],
[ErrorConfig.MaybeSubstringNotFound()])
elif name == 'rjust':
return BuiltinConstMethod('str.rjust', self.get_object(),
[IntType], [BaseStringType])
elif name == 'rpartition':
return BuiltinConstMethod('str.rpartiion',
TupleType.create_tuple([self.get_object(), self.get_object(), self.get_object()]),
[BaseStringType])
elif name == 'rsplit':
return BuiltinConstMethod('str.rsplit', ListType.create_list(self.get_object()),
[], [BaseStringType, IntType])
elif name == 'rstrip':
return BuiltinConstMethod('str.rstrip', self.get_object(),
[], [BaseStringType])
elif name == 'split':
return BuiltinConstMethod('str.split', ListType.create_list(self.get_object()),
[], [BaseStringType, IntType])
elif name == 'splitlines':
return BuiltinConstMethod('str.splitlines', ListType.create_list(self.get_object()),
[], [ANY])
elif name == 'startswith':
return BuiltinConstMethod('str.startswith', BoolType.get_object(),
[BaseStringType], [IntType, IntType])
elif name == 'strip':
return BuiltinConstMethod('str.strip', self.get_object(),
[], [BaseStringType])
elif name == 'swapcase':
return BuiltinConstMethod('str.swapcase', self.get_object())
elif name == 'title':
return BuiltinConstMethod('str.title', self.get_object())
elif name == 'upper':
return BuiltinConstMethod('str.upper', self.get_object())
elif name == 'zfill':
return BuiltinConstMethod('str.zfill', self.get_object(),
[IntType])
raise NodeAttrError(name)
def update_op(self, lobj, robj):
from pyntch.basic_types import NumberType, IntType, BaseStringType, BUILTIN_OBJECT
from pyntch.aggregate_types import ListType, ListObject, TupleType
from pyntch.klass import InstanceObject
if (lobj, robj) in self.received: return
self.received.add((lobj, robj))
# special handling for a formatting (%) operator
ltype = lobj.get_type()
rtype = robj.get_type()
if (lobj.is_type(BaseStringType.get_typeobj()) and self.op == 'Mod'):
self.computed.add((lobj, robj))
lobj.connect(self.recv)
return
# for numeric operation, the one with a higher rank is chosen.
if (lobj.is_type(NumberType.get_typeobj())
and robj.is_type(NumberType.get_typeobj())
and self.op in ('Add', 'Sub', 'Mul', 'Div', 'Mod', 'FloorDiv',
'Power', 'LeftShift', 'RightShift')):
self.computed.add((lobj, robj))
if ltype.get_rank() < rtype.get_rank():
robj.connect(self.recv)
else:
lobj.connect(self.recv)
return
if (lobj.is_type(IntType.get_typeobj())
and robj.is_type(IntType.get_typeobj())
and self.op in ('Bitand', 'Bitor', 'Bitxor')):
self.computed.add((lobj, robj))
robj.connect(self.recv)
return
# for string operation, only Add is supported.
if (lobj.is_type(BaseStringType.get_typeobj())
and robj.is_type(BaseStringType.get_typeobj())
and self.op == 'Add'):
self.computed.add((lobj, robj))
robj.connect(self.recv)
return
# adding lists.
if (self.op == 'Add' and (lobj.is_type(ListType.get_typeobj())
and robj.is_type(ListType.get_typeobj()))):
if not self.listobj:
self.listobj = ListType.create_list()
self.listobj.connect(self.recv)
self.computed.add((lobj, robj))
lobj.connect_element(self.listobj)
robj.connect_element(self.listobj)
return
# multiplying a list by an integer.
if self.op == 'Mul':
if lobj.is_type(ListType.get_typeobj()) and robj.is_type(
IntType.get_typeobj()):
self.computed.add((lobj, robj))
lobj.connect(self.recv)
return
elif lobj.is_type(IntType.get_typeobj()) and robj.is_type(
ListType.get_typeobj()):
self.computed.add((lobj, robj))
robj.connect(self.recv)
return
# adding tuples.
if (self.op == 'Add' and (lobj.is_type(TupleType.get_typeobj())
and robj.is_type(TupleType.get_typeobj()))):
if not self.tupleobj:
self.tupleobj = TupleType.create_tuple()
self.tupleobj.connect(self.recv)
self.computed.add((lobj, robj))
lobj.connect_element(self.tupleobj)
robj.connect_element(self.tupleobj)
return
# multiplying a tuple by an integer.
if self.op == 'Mul':
if lobj.is_type(TupleType.get_typeobj()) and robj.is_type(
IntType.get_typeobj()):
self.computed.add((lobj, robj))
lobj.connect(self.recv)
return
elif lobj.is_type(IntType.get_typeobj()) and robj.is_type(
TupleType.get_typeobj()):
self.computed.add((lobj, robj))
robj.connect(self.recv)
return
# other valid operations.
k = (ltype.typename(), self.op, rtype.typename())
if k in self.VALID_TYPES:
self.computed.add((lobj, robj))
BUILTIN_OBJECT[self.VALID_TYPES[k]].connect(self.recv)
return
# Handle optional methods.
if isinstance(lobj, InstanceObject):
result = OptMethodCall(self.frame, self.anchor, lobj,
self.LMETHOD[self.op], [robj])
result.connect(lambda src: self.recv_result(src, (lobj, robj)))
if isinstance(robj, InstanceObject):
result = OptMethodCall(self.frame, self.anchor, robj,
self.RMETHOD[self.op], [lobj])
result.connect(lambda src: self.recv_result(src, (lobj, robj)))
return
def update_op(self, lobj, robj):
from pyntch.basic_types import NumberType, IntType, BaseStringType, BUILTIN_OBJECT
from pyntch.aggregate_types import ListType, ListObject, TupleType
from pyntch.klass import InstanceObject
if (lobj,robj) in self.received: return
self.received.add((lobj,robj))
# special handling for a formatting (%) operator
ltype = lobj.get_type()
rtype = robj.get_type()
if (lobj.is_type(BaseStringType.get_typeobj()) and
self.op == 'Mod'):
self.computed.add((lobj,robj))
lobj.connect(self.recv)
return
# for numeric operation, the one with a higher rank is chosen.
if (lobj.is_type(NumberType.get_typeobj()) and robj.is_type(NumberType.get_typeobj()) and
self.op in ('Add','Sub','Mul','Div','Mod','FloorDiv','Power','LeftShift','RightShift')):
self.computed.add((lobj,robj))
if ltype.get_rank() < rtype.get_rank():
robj.connect(self.recv)
else:
lobj.connect(self.recv)
return
if (lobj.is_type(IntType.get_typeobj()) and robj.is_type(IntType.get_typeobj()) and
self.op in ('Bitand','Bitor','Bitxor')):
self.computed.add((lobj,robj))
robj.connect(self.recv)
return
# for string operation, only Add is supported.
if (lobj.is_type(BaseStringType.get_typeobj()) and robj.is_type(BaseStringType.get_typeobj()) and
self.op == 'Add'):
self.computed.add((lobj,robj))
robj.connect(self.recv)
return
# adding lists.
if (self.op == 'Add' and
(lobj.is_type(ListType.get_typeobj()) and robj.is_type(ListType.get_typeobj()))):
if not self.listobj:
self.listobj = ListType.create_list()
self.listobj.connect(self.recv)
self.computed.add((lobj,robj))
lobj.connect_element(self.listobj)
robj.connect_element(self.listobj)
return
# multiplying a list by an integer.
if self.op == 'Mul':
if lobj.is_type(ListType.get_typeobj()) and robj.is_type(IntType.get_typeobj()):
self.computed.add((lobj,robj))
lobj.connect(self.recv)
return
elif lobj.is_type(IntType.get_typeobj()) and robj.is_type(ListType.get_typeobj()):
self.computed.add((lobj,robj))
robj.connect(self.recv)
return
# adding tuples.
if (self.op == 'Add' and
(lobj.is_type(TupleType.get_typeobj()) and robj.is_type(TupleType.get_typeobj()))):
if not self.tupleobj:
self.tupleobj = TupleType.create_tuple()
self.tupleobj.connect(self.recv)
self.computed.add((lobj,robj))
lobj.connect_element(self.tupleobj)
robj.connect_element(self.tupleobj)
return
# multiplying a tuple by an integer.
if self.op == 'Mul':
if lobj.is_type(TupleType.get_typeobj()) and robj.is_type(IntType.get_typeobj()):
self.computed.add((lobj,robj))
lobj.connect(self.recv)
return
elif lobj.is_type(IntType.get_typeobj()) and robj.is_type(TupleType.get_typeobj()):
self.computed.add((lobj,robj))
robj.connect(self.recv)
return
# other valid operations.
k = (ltype.typename(), self.op, rtype.typename())
if k in self.VALID_TYPES:
self.computed.add((lobj,robj))
BUILTIN_OBJECT[self.VALID_TYPES[k]].connect(self.recv)
return
# Handle optional methods.
if isinstance(lobj, InstanceObject):
result = OptMethodCall(self.frame, self.anchor, lobj, self.LMETHOD[self.op], [robj])
result.connect(lambda src: self.recv_result(src, (lobj, robj)))
if isinstance(robj, InstanceObject):
result = OptMethodCall(self.frame, self.anchor, robj, self.RMETHOD[self.op], [lobj])
result.connect(lambda src: self.recv_result(src, (lobj, robj)))
return
