def evalArg(self, receiver, context, m, *args):
if len(args) > 1:
return runtime.find("Tuple").clone(tuple(arg.eval(context) for arg in args))
elif len(args) == 1:
return args[0].eval(context)
else:
return runtime.find("None")
def __init__(self, value=u""):
super(String, self).__init__(value=value)
self.create_methods()
try:
self.parent = runtime.find("String")
except AttributeError:
self.parent = runtime.find("Object")
def update_status(self):
mode = self.value.mode
closed = self.value.closed
filename = self.value.name
self["mode"] = runtime.find("String").clone(mode)
self["filename"] = runtime.find("String").clone(filename)
if closed:
self["closed"] = runtime.find("True")
else:
self["closed"] = runtime.find("False")
def __init__(self):
super(System, self).__init__()
self["args"] = self.build_args()
self["version"] = runtime.find("String").clone((mio.__version__))
self["stdin"] = File(sys.stdin)
self["stdout"] = File(sys.stdout)
self["stderr"] = File(sys.stderr)
self.create_methods()
self.parent = runtime.find("Object")
def __init__(self):
super(Traits, self).__init__()
self.create_objects()
self.create_methods()
self.parent = runtime.find("Object")
def _del(self, receiver, context, m, key):
key = unicode(key.eval(context))
value = receiver[key]
del receiver[key]
if isinstance(value, Object):
value.bindig = None
return runtime.find("None")
def find(self, receiver, context, m, sub, start=None, end=None):
sub = bytes(sub.eval(context))
start = int(start.eval(context)) if start is not None else None
end = int(end.eval(context)) if end is not None else None
return runtime.find("Number").clone(
receiver.value.find(sub, start, end)
)
def __init__(self):
super(Importer, self).__init__()
self["paths"] = self.build_paths()
self.create_methods()
self.parent = runtime.find("Object")
def __init__(self):
super(Module, self).__init__()
self.file = None
self.name = None
self.create_methods()
self.parent = runtime.find("Object")
def __init__(self):
super(Continuation, self).__init__()
self.context = None
self.message = None
self.create_methods()
self.parent = runtime.find("Object")
def __init__(self):
super(Trait, self).__init__()
self.requirements = []
self.create_methods()
self.parent = runtime.find(
"Trait" if self.__class__ is not Trait else "Object")
def __init__(self, path=None, expanduser=False):
super(Path, self).__init__()
path = posix.getcwdu() if path is None else path
self.value = posixpath.expanduser(path) if expanduser else path
self.create_methods()
self.parent = runtime.find("Object")
def __init__(self):
super(Error, self).__init__()
self["type"] = None
self["message"] = None
self.create_methods()
self.parent = runtime.find("Object")
def __init__(self):
super(Range, self).__init__()
self.start = None
self.stop = None
self.step = None
self.create_methods()
self.parent = runtime.find("Object")
def __init__(self):
super(State, self).__init__()
self.isContinue = False
self.isReturn = False
self.isBreak = False
self.create_methods()
self.parent = runtime.find("Object")
def test_setParent(mio):
assert mio.eval("World = Object clone()")
assert mio.eval("World parent") == runtime.find("Object")
with raises(TypeError):
mio.eval("World setParent(World)", reraise=True)
assert mio.eval("Foo = Object clone()")
assert mio.eval("World setParent(Foo)")
assert mio.eval("World parent") == mio.eval("Foo")
def make_chain(messages, all=True):
root = node = None
while messages:
if len(messages) > 1 and is_assignment(messages[1]):
name = messages.pop(0).name
object = runtime.find("String").clone(name)
key = Message(name, object)
op = messages.pop(0)
if op.name == "=" and op.next is not None and op.next.name in ("()", "[]", "{}",):
value = Message(
"()", args=[Message(op.next.name, args=op.next.args)])
elif op.args:
value = Message("()", args=op.args)
else:
value = make_chain(messages, all=False)
message = Message("set", args=[key, value])
elif is_operator(messages[0]):
message = messages.pop(0)
if messages and not message.args:
if operators.get(message.name) == 1:
arg = messages.pop(0)
# Set the argument (a Message) previous attribute to the
# current message
arg.previous = message
message.args.append(arg)
message.call = True
else:
chain = make_chain(messages, all=False)
if chain is not None:
# Set the argument (a Message) previous attribute to
# the current message
chain.previous = message
message.args.append(chain)
message.call = True
elif message.next is not None:
chain = message.next
message.next = None
chain.previous = message
message.args.append(chain)
message.call = True
elif messages[0].terminator and not all:
break
else:
message = messages.pop(0)
if root is None:
root = node = message
else:
node.next = node = message
return root
def __call__(self, receiver, context=None, m=None, *args):
self.create_locals(receiver, context, m)
self.locals.attrs.update(self.kwargs)
# Set positional arguments *args
if len(self.args) == 1 and self.args[0].name == "*":
# XXX: Can we make this just a list of args? Or always a list of
# messages?
self.locals[self.args[0].args[0].name] = runtime.find("List").clone(
[
arg.eval(context) if isinstance(arg, Message) else arg
for arg in args
if not isinstance(arg, Message) or (isinstance(arg, Message) and arg.name != "set" and not arg.args)
]
)
else:
# Set positional arguments
for i, arg in enumerate(self.args):
if i < len(args):
self.locals[arg.name] = args[i].eval(context) if isinstance(args[i], Message) else args[i]
else:
self.locals[arg.name] = runtime.find("None")
# Set keyword argumetns **kwargs
if "**" in [arg.name for arg in self.args]:
i = [arg.name for arg in self.args].index("**")
d = {}
for arg in [arg for arg in args if arg.name == "set"]:
d[arg.args[0].name] = arg.eval(context)
self.locals[self.args[i].args[0].name] = runtime.find("Dict").clone(d)
else:
# Set default keyword argumetns
for k, v in self.kwargs.items():
self.locals[k] = v
# Set keyword arguments
for arg in [arg for arg in args if isinstance(arg, Message) and arg.name == "set"]:
self.locals[arg.args[0].name] = arg.eval(context)
return self.body.eval(self.locals, self.locals)
def _method(self, receiver, context, m, *args):
args, body = args[:-1], args[-1:][0]
# Evaluate kwargs first
ctx = runtime.find("Object").clone()
kwargs = OrderedDict([(arg.args[0].name, arg.eval(ctx)) for arg in args if arg.name == "set"])
args = [arg for arg in args if not arg.name == "set"]
from mio.core.block import Block
return Block(body, args, kwargs)
def __init__(self, body=None, args=None, kwargs=None, scope=None):
super(Block, self).__init__()
self.body = body if body is not None else self
self.args = args if args is not None else ()
self.kwargs = kwargs if kwargs is not None else {}
self.scope = scope
self.locals = None
self.create_methods()
self.parent = runtime.find("Object")
def _import(self, receiver, context, m, name):
name = name.name if name.value is None else unicode(name.eval(context))
# In case we're importing from inside a module.
if context.type == "Module" and receiver is context:
m = parse(tokenize("""Importer import("{0:s}")""".format(name)))
return m.eval(receiver, context, m)
if name == "*":
context.attrs.update(receiver.attrs)
else:
context[name] = receiver[name]
return runtime.find("None")
def create_locals(self, receiver, context, m):
self.locals = Locals()
if self.scope is None:
self.locals["self"] = receiver
self.locals.parent = receiver
elif isinstance(self.scope, Locals):
if "self" in self.scope:
self.locals["self"] = self.scope["self"]
self.locals["this"] = self.scope
self.locals.parent = self.scope
else:
self.locals["self"] = self.locals
self.locals.parent = runtime.find("Object")
call = Call()
call.parent = runtime.find("Object")
call["message"] = m
call["target"] = receiver
call["sender"] = context
self.locals["call"] = call
def mio__len__(self, receiver, context, m):
start = receiver.start
if receiver.stop is None:
stop, start = start, 0
else:
stop = receiver.stop
step = 1 if receiver.step is None else receiver.step
if (start < stop and step > 0) or (start > stop and step < 0):
length = ((stop - start) / step) + (stop % step)
else:
length = 0
return runtime.find("Number").clone(length)
def __init__(self, name=None, value=None, args=None):
super(Message, self).__init__(value=value)
self.name = name
self.value = value
self.args = args if args is not None else []
self.call = args is not None
self.terminator = self.value is None and name in ["\r", "\n", ";"]
self._previous = self
self._first = self
self._last = self
self._next = None
self.create_methods()
self.parent = runtime.find("Object")
def make_string(n):
if n and n[0] in "bu":
prefix = n[0]
n = n[1:]
else:
prefix = "u"
if len(n) > 3 and (n[:3] in ("'''", '"""')):
n = n[3:-3]
else:
n = n[1:-1]
if prefix == "u":
s = n.decode("unicode-escape")
else:
s = n.decode("string-escape")
return runtime.find("String" if prefix == "u" else "Bytes").clone(s)
def getItem(self, receiver, context, m, i):
i = int(i.eval(context))
start = receiver.start
if receiver.stop is None:
stop, start = start, 0
else:
stop = receiver.stop
step = 1 if receiver.step is None else receiver.step
if (start < stop and step > 0) or (start > stop and step < 0):
length = ((stop - start) / step) + (stop % step)
else:
length = 0
if i > length:
raise IndexError("range index out of range")
value = start + (step * i)
return runtime.find("Number").clone(value)
def getStr(self, receiver, context, m):
return runtime.find("String").clone(unicode(receiver))
def getRepr(self, receiver, context, m):
return runtime.find("String").clone(repr(receiver))
def cmp(self, receiver, context, m, other):
return runtime.find("Number").clone(cmp(receiver, other.eval(context)))
def keys(self, receiver, context, m):
String = runtime.find("String")
keys = [String.clone(key) for key in receiver.attrs.keys()]
return runtime.find("List").clone(keys)
