Python lltype.cast_primitive函数代码示例

 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