Function write_base_value

debugger/src/value/writer.rs:210–558

This should not call methods of `RVal`

(t: &mut RValueWriter, v: &SBValue, mut r: usize)

/// This should not call methods of `RVal`
fn write_base_value(t: &mut RValueWriter, v: &SBValue, mut r: usize) -> Result<Bytes> {
    if r == 0 {
        log::trace!("Recursive limit reached for {:?}", v.type_name());
        return Ok(t.opaque_v());
    }
    r -= 1;
    let vtype = v.type_();
    let type_class = vtype.type_class();
    let write_primitive = |ty: &str| -> Result<Bytes> {
        Ok(match v.byte_size() {
            1 => t.prim_v(ty, &value_to_bytes::<1>(v)?),
            2 => t.prim_v(ty, &value_to_bytes::<2>(v)?),
            4 => t.prim_v(ty, &value_to_bytes::<4>(v)?),
            8 => t.prim_v(ty, &value_to_bytes::<8>(v)?),
            16 => t.prim_v(ty, &value_to_bytes::<16>(v)?),
            _ => panic!("Not a primitive"),
        })
    };
    if type_class.contains(TypeClass::Builtin) {
        let ty = vtype.name();
        return Ok(if !ty.is_empty() {
            write_primitive(ty)?
        } else {
            t.opaque_v()
        });
    }
    if type_class.contains(TypeClass::Array) {
        let vtype = v.type_();
        let typename = vtype.name();
        return Ok(if typename.starts_with("[u8;") {
            let len = v.byte_size().min(*MAX_ARRAY_SIZE);
            let mut bytes = vec![0; len];
            v.data()
                .read_raw_data(0, &mut bytes)
                .map_err(|_| WriteErr)?;
            t.bytes_v(typename, Bytes::from(bytes))
        } else {
            let mut elems = Vec::with_capacity((v.num_children() as usize).min(*MAX_ARRAY_SIZE));
            for c in v.children().take(*MAX_ARRAY_SIZE) {
                elems.push(write_value(t, &c, r)?);
            }
            t.arr_v(elems.into_iter())
        });
    }
    if type_class.intersects(TypeClass::Pointer | TypeClass::Reference) {
        let raw_addr = value_to_bytes::<8>(v)?;
        let addr = Addr::new(&raw_addr);
        let raw_addr = u64::from_ne_bytes(raw_addr);
        if t.alloc_env(addr) {
            let pointee = vtype.pointee_type();
            if !pointee.is_valid() {
                bail!();
            }
            let pointee = pointee.name();
            let value = if pointee.starts_with(RC_BOX_DYN) || pointee.starts_with(ARC_INNER_DYN) {
                let ty = if pointee.starts_with(RC_BOX_DYN) {
                    "rc"
                } else {