def Integer_to_string(integer, base):
    base = 10 if base is None else base.value
    if base >= len(digits):
        raise space.unwind(space.LError(u"not enough digits to represent this base %d" % base))
    if base < 0:
        raise space.unwind(space.LError(u"negative base not supported"))
    return space.String(integer_to_string(integer.value, base))

 def setitem(self, index, value):
     if not isinstance(index, Integer):
         raise space.unwind(space.LTypeError(u"index not an integer"))
     if not 0 <= index.value < len(self.contents):
         raise space.unwind(space.LKeyError(self, index))
     self.contents[index.value] = value
     return value

def cast(x, cls, info=u"something"):
    if isinstance(x, cls): # This here means that cast won't change object
        return x           # if it is already correct type.
    try:
        fn = cast_methods[cls]
    except KeyError as _:
        raise space.unwind(space.LTypeError(u"expected %s is %s, got %s" % (
            info, cls.interface.name, x.repr())))
    res = fn(x)
    if isinstance(res, cls):
        return res
    # TODO: Consider alternative ways to say it. :)
    raise space.unwind(space.LTypeError(u"implicit conversion of %s at %s into %s returned %s" % (
        x.repr(), info, cls.interface.name, res.repr())))

 def setitem(self, index, value):
     # TODO: Add slice support to this side.
     index = space.cast(index, Integer, u"index not an integer")
     if not 0 <= index.value < len(self.contents):
         raise space.unwind(space.LKeyError(self, index))
     self.contents[index.value] = value
     return value

 def call(self, argv):
     varargs = self.function.flags & 1 == 1
     argc = self.function.argc
     topc = self.function.topc
     L = len(argv)
     if L < argc:
         # The pc=0 refers to the function itself. This entry
         # is really helpful when trying to determine the origin of a CallError.
         head_entry = TraceEntry(rffi.r_long(0),
             self.function.unit.sources,
             self.function.sourcemap, self.function.unit.path)
         unwinder = space.unwind(space.LCallError(argc, topc, varargs, L))
         unwinder.traceback.contents.append(head_entry)
         raise unwinder
     # We are using this trait.
     #if L > topc and not varargs:
     #    raise space.Error(u"too many arguments [%d], from %d to %d arguments allowed" % (L, argc, topc))
     frame = Frame(self.function, self.frame.module, self.frame)
     for i in range(min(topc, L)):
         frame.local[i] = argv[i]
     if varargs:
         frame.local[topc] = space.List(argv[min(topc, L):])
     regv = new_register_array(self.function.regc)
     if self.function.flags & 2 != 0:
         return Generator(0, self.function.block, regv, frame)
     else:
         return interpret(0, self.function.block, regv, frame)

def from_object(obj):
    if as_i(obj.getitem(space.String(u"version"))) != 0:
        raise space.unwind(space.LError(u"bytecode version=0 required"))

    sources = as_list(obj.getitem(space.String(u"sources")))
    constants = as_list(obj.getitem(space.String(u"constants")))

    functions = []
    for function_list in as_list(obj.getitem(space.String(u"functions"))):
        flags = as_i( function_list.getitem(space.String(u"flags")))
        regc = as_i( function_list.getitem(space.String(u"regc")))
        argc = rffi.r_ulong(as_i( function_list.getitem(space.String(u"argc"))))
        topc = rffi.r_ulong(as_i( function_list.getitem(space.String(u"topc"))))
        localc = as_i( function_list.getitem(space.String(u"localc")))
        block_list = as_u8a(function_list.getitem(space.String(u"code")))
        sourcemap = function_list.getitem(space.String(u"sourcemap"))
        exc_table = as_list(function_list.getitem(space.String(u"exceptions")))
        block = lltype.malloc(u16_array, block_list.length/2)
        for i in range(block_list.length/2):
            a = rffi.r_long(block_list.uint8data[i*2+0])
            b = rffi.r_long(block_list.uint8data[i*2+1])
            block[i] = rffi.r_ushort((a << 8) | b)
        excs = []
        for n in exc_table:
            excs.append(Exc(
                rffi.r_ulong(as_i(n.getitem(space.Integer(0)))),
                rffi.r_ulong(as_i(n.getitem(space.Integer(1)))),
                rffi.r_ulong(as_i(n.getitem(space.Integer(2)))),
                rffi.r_ulong(as_i(n.getitem(space.Integer(3)))),
            ))
        functions.append(Function(flags, regc, argc, topc, localc, block, sourcemap, excs[:]))
    return Program(Unit(constants[:], functions[:], sources[:]))

 def setitem(self, index, value):
     index = space.cast(index, numbers.Integer, u"index not an integer")
     if not 0 <= index.value < self.length:
         raise space.unwind(space.LKeyError(self, index))
     value = space.cast(value, numbers.Integer, u"value not an integer")
     self.uint8data[index.value] = rffi.r_uchar(value.value)
     return value

def List_pop(self, index):
    if index:
        index = index.value
    else:
        index = len(self.contents) - 1
    if not 0 <= index < len(self.contents):
        raise space.unwind(space.LKeyError(self, space.Integer(index)))
    return self.contents.pop(index)

def sizeof_a(tp, n):
    assert isinstance(tp, Type)
    if tp.size == 0 or tp.align == 0:
        raise unwind(LTypeError(u"cannot determine size of opaque type"))
    if tp.parameter is not None:
        return tp.size + sizeof(tp.parameter)*n
    else:
        return tp.size * n

 def store(self, pool, offset, value):
     for rtype in signed_types:
         if self.size == rffi.sizeof(rtype):
             pnt = rffi.cast(rffi.CArrayPtr(rtype), offset)
             pnt[0] = rffi.cast(rtype, to_int(value))
             break
     else:
         raise unwind(LTypeError(u"undefined ffi type: %s" % self.repr()))
     return value

 def call(self, argv):
     if len(argv) != 1:
         raise space.unwind(space.LCallError(1, 1, False, len(argv)))
     module = argv[0]
     assert isinstance(module, space.Module)
     entry = self.unit.functions[0]
     frame = Frame(entry, module, None)
     regv = new_register_array(entry.regc)
     return interpret(0, entry.block, regv, frame)

 def getitem(self, index):
     if isinstance(index, space.Slice):
         start, stop, step = index.clamped(0, len(self.contents))
         result = []
         for i in range(start, stop, step):
             result.append(self.contents[i])
         return List(result)
     index = space.cast(index, Integer, u"index not an integer")
     if not 0 <= index.value < len(self.contents):
         raise space.unwind(space.LKeyError(self, index))
     return self.contents[index.value]

 def getitem(self, index):
     if isinstance(index, space.Slice):
         result = []
         start, stop, step = index.clamped(0, len(self.string))
         for i in range(start, stop, step):
             result.append(self.string[i])
         return String(u"".join(result))
     index = space.cast(index, numbers.Integer, u"index not an integer")
     if not 0 <= index.value < len(self.string):
         raise space.unwind(space.LKeyError(self, index))
     return String(self.string[index.value])

def to_float(obj):
    if isinstance(obj, Float):
        return obj.number
    elif isinstance(obj, Integer):
        return float(obj.value)
    elif isinstance(obj, Boolean):
        if is_true(obj):
            return 1.0
        else:
            return 0.0
    else:
        raise space.unwind(space.LTypeError(u"expected float value"))

def to_int(obj):
    if isinstance(obj, Float):
        return int(obj.number)
    elif isinstance(obj, Integer):
        return obj.value
    elif isinstance(obj, Boolean):
        if is_true(obj):
            return 1
        else:
            return 0
    else:
        raise space.unwind(space.LTypeError(u"expected int value"))

 def setattr_force(self, name, value):
     try:
         cell = jit.promote(self.lookup(name, assign=True))
         if isinstance(cell, FrozenCell):
             raise space.unwind(space.LFrozenError(self))
         elif isinstance(cell, MutableCell):
             cell.slot = value
         else:
             assert False
     except KeyError:
         if self.frozen:
             self.cells[name] = FrozenCell(value)
         else:
             self.cells[name] = MutableCell(value)
     return value

 def fancy_frame(argv):
     args = ()
     L = len(argv)
     if L < argc or (L > topc and not variadic):
         raise space.unwind(space.LCallError(argc, topc, variadic, L))
     for i in argi:
         arg = argv[i]
         if isinstance(arg, argtypes[i]):
             args += (arg,)
         else:
             raise expectations_error(i, argtypes[i].interface.name)
     for j in argj:
         if j < L:
             arg = argv[j]
             if arg is null:
                 arg = None
             elif not isinstance(arg, argtypes[j]):
                 raise expectations_error(j, argtypes[j].interface.name)
         else:
             arg = None
         args += (arg,)
     if variadic:
         args += (argv[min(topc, L):],)
     return func(*args)

 def fancy_frame(argv):
     args = ()
     L = len(argv)
     if L < argc or (L > topc and not variadic):
         raise space.unwind(space.LCallError(argc, topc, variadic, L))
     for i in argi:
         arg = argv[i]
         if isinstance(arg, argtypes[i]):
             args += (arg,)
         else:
             args += (space.cast(arg, argtypes[i], u"arg:%d"%i),)
     for j in argj:
         if j < L:
             arg = argv[j]
             if arg is null:
                 arg = None
             elif not isinstance(arg, argtypes[j]):
                 arg = space.cast(arg, argtypes[j], u"arg:%d"%j)
         else:
             arg = None
         args += (arg,)
     if variadic:
         args += (argv[min(topc, L):],)
     return func(*args)

def List_insert(self, index, obj):
    val = index.value
    if not 0 <= val <= len(self.contents):
        raise space.unwind(space.LKeyError(self, index))
    self.contents.insert(val, obj)
    return space.null

def as_i(obj):
    if not isinstance(obj, space.Integer):
        raise space.unwind(space.LTypeError(u"expected integer"))
    return obj.value