def get_attr(self, frame, anchor, name, write=False):
from pyntch.aggregate_types import ListType
if write: raise NodeAssignError(name)
if name == 'close':
return BuiltinConstMethod('file.close', NoneType.get_object())
elif name == 'closed':
return BoolType.get_object()
elif name == 'encoding':
return StrType.get_object()
elif name == 'fileno':
return BuiltinConstMethod('file.fileno', IntType.get_object())
elif name == 'flush':
return BuiltinConstMethod('file.flush', NoneType.get_object())
elif name == 'isatty':
return BuiltinConstMethod('file.isatty', BoolType.get_object())
elif name == 'mode':
return StrType.get_object()
elif name == 'name':
return StrType.get_object()
elif name == 'newlines':
return NoneType.get_object()
elif name == 'next':
return BuiltinConstMethod('file.next', StrType.get_object())
elif name == 'read':
return BuiltinConstMethod('file.read', StrType.get_object(), [],
[IntType], [ErrorConfig.MaybeEOFError()])
elif name == 'readline':
return BuiltinConstMethod('file.readline', StrType.get_object(),
[], [IntType],
[ErrorConfig.MaybeEOFError()])
elif name == 'readlines':
return BuiltinConstMethod(
'file.readlines', ListType.create_list(StrType.get_object()),
[], [IntType], [ErrorConfig.MaybeEOFError()])
elif name == 'seek':
return BuiltinConstMethod('file.seek', NoneType.get_object(),
[IntType], [IntType],
[ErrorConfig.MaybeEOFError()])
elif name == 'softspace':
return IntType.get_object()
elif name == 'tell':
return BuiltinConstMethod(
'file.tell',
IntType.get_object(),
expts=[ErrorConfig.MaybeFileIllegalSeek()])
elif name == 'truncate':
return BuiltinConstMethod('file.truncate', NoneType.get_object(),
[], [IntType])
elif name == 'write':
return BuiltinConstMethod('file.write', NoneType.get_object(),
[BaseStringType])
elif name == 'writelines':
return BuiltinConstMethod('file.writestrings',
NoneType.get_object(),
[[BaseStringType]])
elif name == 'xreadlines':
return self
raise NodeAttrError(name)
def __init__(self, frame, anchor, func, objs): self.frame = frame self.anchor = anchor self.received = set() self.args = tuple( IterElement(frame, anchor, obj) for obj in objs ) self.listobj = ListType.create_list() CompoundTypeNode.__init__(self, [self.listobj]) func.connect(self.recv_func) return
def __init__(self, frame, anchor, func, objs):
self.frame = frame
self.anchor = anchor
self.received = set()
self.args = tuple(IterElement(frame, anchor, obj) for obj in objs)
self.listobj = ListType.create_list()
CompoundTypeNode.__init__(self, [self.listobj])
func.connect(self.recv_func)
return
def get_attr(self, frame, anchor, name, write=False):
from pyntch.aggregate_types import ListType
if write: raise NodeAssignError(name)
if name == 'close':
return BuiltinConstMethod('file.close', NoneType.get_object())
elif name == 'closed':
return BoolType.get_object()
elif name == 'encoding':
return StrType.get_object()
elif name == 'fileno':
return BuiltinConstMethod('file.fileno', IntType.get_object())
elif name == 'flush':
return BuiltinConstMethod('file.flush', NoneType.get_object())
elif name == 'isatty':
return BuiltinConstMethod('file.isatty', BoolType.get_object())
elif name == 'mode':
return StrType.get_object()
elif name == 'name':
return StrType.get_object()
elif name == 'newlines':
return NoneType.get_object()
elif name == 'next':
return BuiltinConstMethod('file.next', StrType.get_object())
elif name == 'read':
return BuiltinConstMethod('file.read', StrType.get_object(),
[], [IntType],
[ErrorConfig.MaybeEOFError()])
elif name == 'readline':
return BuiltinConstMethod('file.readline', StrType.get_object(),
[], [IntType],
[ErrorConfig.MaybeEOFError()])
elif name == 'readlines':
return BuiltinConstMethod('file.readlines', ListType.create_list(StrType.get_object()),
[], [IntType],
[ErrorConfig.MaybeEOFError()])
elif name == 'seek':
return BuiltinConstMethod('file.seek', NoneType.get_object(),
[IntType], [IntType],
[ErrorConfig.MaybeEOFError()])
elif name == 'softspace':
return IntType.get_object()
elif name == 'tell':
return BuiltinConstMethod('file.tell', IntType.get_object(),
expts=[ErrorConfig.MaybeFileIllegalSeek()])
elif name == 'truncate':
return BuiltinConstMethod('file.truncate', NoneType.get_object(),
[], [IntType])
elif name == 'write':
return BuiltinConstMethod('file.write', NoneType.get_object(),
[BaseStringType])
elif name == 'writelines':
return BuiltinConstMethod('file.writestrings', NoneType.get_object(),
[[BaseStringType]])
elif name == 'xreadlines':
return self
raise NodeAttrError(name)
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 __init__(self):
BuiltinConstFunc.__init__(self, 'range', ListType.create_list(IntType.get_object()),
[IntType],
[IntType, IntType])
return
def __init__(self): BuiltinConstFunc.__init__(self, 'dir', ListType.create_list(StrType.get_object()), [], [ANY]) 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 process_args(self, frame, anchor, args, kwargs):
seq = ListType.create_list(elemall=IterElement(frame, anchor, args[0]))
ListObject.SortMethod('sorted',
seq).process_args(frame, anchor, args[1:],
kwargs)
return seq
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 __init__(self):
BuiltinConstFunc.__init__(self, 'dir',
ListType.create_list(StrType.get_object()),
[], [ANY])
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
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 process_args(self, frame, anchor, args, kwargs):
seq = ListType.create_list(elemall=IterElement(frame, anchor, args[0]))
ListObject.SortMethod('sorted', seq).process_args(frame, anchor, args[1:], kwargs)
return seq
def __init__(self):
BuiltinConstFunc.__init__(self, 'range',
ListType.create_list(IntType.get_object()),
[IntType], [IntType, IntType])
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
