def f(x):
     x = cast_primitive(UnsignedLongLong, x)
     x <<= 60
     x /= 3
     x <<= 1
     x = cast_primitive(SignedLongLong, x)
     x >>= 32
     return cast_primitive(Signed, x)

def boxresult(RESULT, result):
    if isinstance(RESULT, ootype.OOType):
        return history.BoxObj(ootype.cast_to_object(result))
    elif RESULT is lltype.Float:
        return history.BoxFloat(result)
    else:
        return history.BoxInt(lltype.cast_primitive(ootype.Signed, result))

 def revealconst(self, T):
     if isinstance(T, lltype.Ptr):
         return lltype.cast_int_to_ptr(T, self.get_integer_value())
     elif T is llmemory.Address:
         return llmemory.cast_int_to_adr(self.get_integer_value())
     else:
         return lltype.cast_primitive(T, self.get_integer_value())

def cast_whatever_to_int(T, value):
    if isinstance(T, lltype.Ptr):
        return lltype.cast_ptr_to_int(value)
    elif T is llmemory.Address:
        return llmemory.cast_adr_to_int(value)
    else:
        return lltype.cast_primitive(lltype.Signed, value)

def cast_int_to_whatever(T, value):
    if isinstance(T, lltype.Ptr):
        return lltype.cast_int_to_ptr(T, value)
    elif T is llmemory.Address:
        return llmemory.cast_int_to_adr(value)
    else:
        return lltype.cast_primitive(T, value)

 def convert_const(self, value):
     if isinstance(value, objectmodel.Symbolic):
         return value
     T = typeOf(value)
     if isinstance(T, Number) or T is Bool:
         return cast_primitive(self.lowleveltype, value)
     raise TyperError("not an integer: %r" % (value,))

def ll_array_set(ITEM, it0, it1):
    if it0.size == 0:
        return # empty LHS..
    ll_assert(it0.size == it1.size, "it0.size == it1.size")
    while it0.index < it0.size:
        it0.dataptr[0] = cast_primitive(ITEM, it1.dataptr[0])
        it0.ll_next()
        it1.ll_next()

 def ll_str2unicode(str):
     lgt = len(str.chars)
     s = mallocunicode(lgt)
     for i in range(lgt):
         if ord(str.chars[i]) > 127:
             raise UnicodeDecodeError
         s.chars[i] = cast_primitive(UniChar, str.chars[i])
     return s

def os_open_lltypeimpl(path, flags, mode):
    l_path = rffi.str2charp(path)
    mode = lltype.cast_primitive(mode_t, mode)
    result = os_open(l_path, flags, mode)
    rffi.free_charp(l_path)
    if result == -1:
        raise OSError(rffi.c_errno, "os_open failed")
    return result

 def ll_encode_latin1(self, s):
     length = len(s.chars)
     result = mallocstr(length)
     for i in range(length):
         c = s.chars[i]
         if ord(c) > 255:
             raise UnicodeEncodeError("character not in latin1 range")
         result.chars[i] = cast_primitive(Char, c)
     return result

 def ll_str(self, value):
     sb = ootype.new(ootype.StringBuilder)
     lgt = value.ll_strlen()
     sb.ll_allocate(lgt)
     for i in range(lgt):
         c = value.ll_stritem_nonneg(i)
         if ord(c) > 127:
             raise UnicodeEncodeError("%d > 127, not ascii" % ord(c))
         sb.ll_append_char(cast_primitive(Char, c))
     return sb.ll_build()

def unwrap(TYPE, box):
    if TYPE is lltype.Void:
        return None
    if isinstance(TYPE, lltype.Ptr):
        return box.getref(TYPE)
    if isinstance(TYPE, ootype.OOType):
        return box.getref(TYPE)
    if TYPE == lltype.Float:
        return box.getfloat()
    else:
        return lltype.cast_primitive(TYPE, box.getint())

def set_future_value(cpu, j, value, typecode):
    if typecode == 'ref':
        refvalue = cpu.ts.cast_to_ref(value)
        cpu.set_future_value_ref(j, refvalue)
    elif typecode == 'int':
        intvalue = lltype.cast_primitive(lltype.Signed, value)
        cpu.set_future_value_int(j, intvalue)
    elif typecode == 'float':
        assert isinstance(value, float)
        cpu.set_future_value_float(j, value)
    else:
        assert False

 def genconst(self, llvalue):
     T = lltype.typeOf(llvalue)
     if T is llmemory.Address:
         return AddrConst(llvalue)
     elif isinstance(T, lltype.Primitive):
         return IntConst(lltype.cast_primitive(lltype.Signed, llvalue))
     elif isinstance(T, lltype.Ptr):
         lladdr = llmemory.cast_ptr_to_adr(llvalue)
         if T.TO._gckind == 'gc':
             self.keepalive_gc_refs.append(lltype.cast_opaque_ptr(llmemory.GCREF, llvalue))
         return AddrConst(lladdr)
     else:
         assert 0, "XXX not implemented"

 def get_string(self, builder, r):
     current = getattr(builder, self.builder_cache)
     if current and r.random() < .8:
         v_string = r.choice(current)
         string = v_string.getref(self.ptr)
     else:
         string = self.alloc(builder.get_index(500, r).getint())
         v_string = ConstPtr(lltype.cast_opaque_ptr(llmemory.GCREF, string))
         current.append(v_string)
     for i in range(len(string.chars)):
         char = r.random_integer() % self.max
         string.chars[i] = lltype.cast_primitive(self.primitive, char)
     return v_string

def _generalcast(T, value):
    if isinstance(T, lltype.Ptr):
        return lltype.cast_pointer(T, value)
    elif T == llmemory.Address:
        return llmemory.cast_ptr_to_adr(value)
    else:
        T1 = lltype.typeOf(value)
        if T1 is llmemory.Address:
            value = llmemory.cast_adr_to_int(value)
        elif isinstance(T1, lltype.Ptr):
            value = lltype.cast_ptr_to_int(value)
        else:
            value = value
        return lltype.cast_primitive(T, value)    

 def _new(x, cpu):
     "NOT_RPYTHON"
     kind = getkind(lltype.typeOf(x))
     if kind == "int":
         intval = lltype.cast_primitive(lltype.Signed, x)
         return BoxInt(intval)
     elif kind == "ref":
         # XXX add ootype support?
         ptrval = lltype.cast_opaque_ptr(llmemory.GCREF, x)
         return BoxPtr(ptrval)
     elif kind == "float":
         return BoxFloat(x)
     else:
         raise NotImplementedError(kind)

 def genconst(self, llvalue):
     T = lltype.typeOf(llvalue)
     if T is llmemory.Address:
         return AddrConst(llvalue)
     elif T is lltype.Bool:
         return BoolConst(lltype.cast_primitive(lltype.Bool, llvalue))
     elif T is lltype.Char:
         return CharConst(lltype.cast_primitive(lltype.Char, llvalue))
     elif T is lltype.Unsigned:
         return UIntConst(lltype.cast_primitive(lltype.Unsigned, llvalue))
     elif T is lltype.Float:
         return FloatConst(lltype.cast_primitive(lltype.Float, llvalue))
     elif isinstance(T, lltype.Primitive):
         return IntConst(lltype.cast_primitive(lltype.Signed, llvalue))
     elif isinstance(T, lltype.Ptr):
         lladdr = llmemory.cast_ptr_to_adr(llvalue)
         #if T.TO._gckind == 'gc':
         #    self.keepalive_gc_refs.append(lltype.cast_opaque_ptr(llmemory.GCREF, llvalue))
         return AddrConst(lladdr)
     else:
         msg = 'XXX not implemented'
         logger.dump(msg)
         assert 0, msg

def PyMember_GetOne(space, obj, w_member):
    addr = rffi.cast(ADDR, obj)
    addr += w_member.c_offset

    member_type = rffi.cast(lltype.Signed, w_member.c_type)
    for converter in integer_converters:
        typ, lltyp, _ = converter
        if typ == member_type:
            result = rffi.cast(rffi.CArrayPtr(lltyp), addr)
            if lltyp is rffi.FLOAT:
                w_result = space.wrap(lltype.cast_primitive(lltype.Float,
                                                            result[0]))
            elif typ == T_BOOL:
                x = rffi.cast(lltype.Signed, result[0])
                w_result = space.wrap(x != 0)
            else:
                w_result = space.wrap(result[0])
            return w_result

    if member_type == T_STRING:
        result = rffi.cast(rffi.CCHARPP, addr)
        if result[0]:
            w_result = PyString_FromString(space, result[0])
        else:
            w_result = space.w_None
    elif member_type == T_STRING_INPLACE:
        result = rffi.cast(rffi.CCHARP, addr)
        w_result = PyString_FromString(space, result)
    elif member_type == T_CHAR:
        result = rffi.cast(rffi.CCHARP, addr)
        w_result = space.wrap(result[0])
    elif member_type == T_OBJECT:
        obj_ptr = rffi.cast(PyObjectP, addr)
        if obj_ptr[0]:
            w_result = from_ref(space, obj_ptr[0])
        else:
            w_result = space.w_None
    elif member_type == T_OBJECT_EX:
        obj_ptr = rffi.cast(PyObjectP, addr)
        if obj_ptr[0]:
            w_result = from_ref(space, obj_ptr[0])
        else:
            w_name = space.wrap(rffi.charp2str(w_member.c_name))
            raise OperationError(space.w_AttributeError, w_name)
    else:
        raise OperationError(space.w_SystemError,
                             space.wrap("bad memberdescr type"))
    return w_result

 def convert_const(self, value):
     if value is None:
         return nullptr(self.lowleveltype.TO)
     #value = getattr(value, '__self__', value)  # for bound string methods
     if not isinstance(value, self.basetype):
         raise TyperError("not a str: %r" % (value,))
     try:
         return self.CACHE[value]
     except KeyError:
         p = self.malloc(len(value))
         for i in range(len(value)):
             p.chars[i] = cast_primitive(self.base, value[i])
         p.hash = 0
         self.ll.ll_strhash(p)   # precompute the hash
         self.CACHE[value] = p
         return p