import rpython.rlib.jit as jit

from rpython.rlib.objectmodel import we_are_translated

class Object(object):

""" Base Object for all VM objects

"""

_attrs_ = ()

def type(self):

if not we_are_translated():

print "FOR TYPE", self

affirm(False, u".type isn't overloaded")

@jit.unroll_safe

def invoke_k(self, args, stack):

from pixie.vm2.code import intern_var

var = intern_var(u"pixie.stdlib", u"-invoke")

new_args = [None] * (len(args) + 1)

new_args[0] = self

for x in range(len(args)):

new_args[x + 1] = args[x]

return var.deref().invoke_k(new_args, stack)

def int_val(self):

affirm(False, u"Expected Number, not " + self.type().name())

return 0

def r_uint_val(self):

affirm(False, u"Expected Number, not " + self.type().name())

return 0

def hash(self):

import pixie.vm2.rt as rt

return rt.wrap(compute_identity_hash(self))

def promote(self):

return self

def get_field(self, k, not_found):

runtime_error(u"Unsupported operation get-field")

def to_str(self):

tp = self.type()

assert isinstance(tp, Type)

return u"<inst " + tp._name + u">"

def to_repr(self):

tp = self.type()

assert isinstance(tp, Type)

return u"<inst " + tp._name + u">"

class TypeRegistry(object):

def __init__(self):

self._types = {}

self._ns_registry = None

def register_type(self, nm, tp):

if self._ns_registry is None:

self._types[nm] = tp

else:

self.var_for_type_and_name(nm, tp)

def var_for_type_and_name(self, nm, tp):

splits = nm.split(u".")

size = len(splits) - 1

assert size >= 0

ns = u".".join(splits[:size])

name = splits[size]

var = self._ns_registry.find_or_make(ns).intern_or_make(name)

var.set_root(tp)

return var

def set_registry(self, registry):

self._ns_registry = registry

for nm in self._types:

tp = self._types[nm]

self.var_for_type_and_name(nm, tp)

def get_by_name(self, nm, default=None):

return self._types.get(nm, default)

_type_registry = TypeRegistry()

def get_type_by_name(nm):

return _type_registry.get_by_name(nm)

class Type(Object):

def __init__(self, name, parent=None, object_inited=True):

assert isinstance(name, unicode), u"Type names must be unicode"

_type_registry.register_type(name, self)

self._name = name

if object_inited:

if parent is None:

parent = Object._type

parent.add_subclass(self)

self._parent = parent

self._subclasses = []

def name(self):

return self._name

def type(self):

return Type._type

def add_subclass(self, tp):

self._subclasses.append(tp)

def subclasses(self):

return self._subclasses

def to_str(self):

return u"<type " + self._name + u">"

def to_repr(self):

return u"<type " + self._name + u">"

Object._type = Type(u"pixie.stdlib.Object", None, False)

Type._type = Type(u"pixie.stdlib.Type")

@jit.elidable_promote()

def istypeinstance(obj_type, t):

if not isinstance(obj_type, Type):

return False

if obj_type is t:

return True

elif obj_type._parent is not None:

obj_type = obj_type._parent

while obj_type is not None:

if obj_type is t:

return True

obj_type = obj_type._parent

return False

else:

return False

class Continuation(object):

should_enter_jit = False

_immutable_ = True

def call_continuation(self, val, stack):

assert False

return None, stack

def get_ast(self):

from pixie.vm2.primitives import nil

return nil

class StackCell(object):

"""Defines an immutable call stack, stacks can be copied, spliced and combined"""

_immutable_fields_ = ["_parent", "_cont"]

def __init__(self, cont, parent_stack):

self._parent = parent_stack

self._cont = cont

def stack_cons(stack, other):

return StackCell(other, stack)

class RuntimeException(Object):

_type = Type(u"pixie.stdlib.RuntimeException")

def __init__(self, msg, kw):

self._msg = msg

self._kw = kw

## TODO: fix

def affirm(f, msg):

if not f:

print msg

raise WrappedException(RuntimeException(msg, u"pixie.stdlib.AssertionException"))

class WrappedException(BaseException):

def __init__(self, ex):

self._ex = ex

def runtime_error(msg, kw=None):

print msg

raise WrappedException(RuntimeException(msg, kw))