ddbug 0.5.0

Display debugging information
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use parser::{FileHash, StructType, Unit};

use crate::Result;
use crate::print::{self, DiffState, PrintHeader, PrintState, ValuePrinter};

fn print_name(ty: &StructType, w: &mut dyn ValuePrinter) -> Result<()> {
    write!(w, "struct ")?;
    if let Some(namespace) = ty.namespace() {
        print::namespace::print(namespace, w)?;
    }
    w.name(ty.name().unwrap_or("<anon>"))?;
    Ok(())
}

pub(crate) fn print_ref(ty: &StructType, w: &mut dyn ValuePrinter, id: usize) -> Result<()> {
    w.link(id, &mut |w| print_name(ty, w))
}

impl<'input> PrintHeader for StructType<'input> {
    fn print_header(&self, state: &mut PrintState) -> Result<()> {
        state.line(|w, _state| print_name(self, w))
    }

    fn print_body(&self, state: &mut PrintState, unit: &Unit) -> Result<()> {
        if state.options().print_source {
            state.field("source", |w, _state| print_source(self, w, unit))?;
        }
        state.field("declaration", |w, state| print_declaration(self, w, state))?;
        state.field("size", |w, state| print_byte_size(self, w, state))?;
        print::inherit::print_list(state, self.inherits())?;
        state.field_expanded("members", |state| print_members(self, state, unit))
    }

    fn diff_header(state: &mut DiffState, a: &Self, b: &Self) -> Result<()> {
        state.line(a, b, |w, _state, x| print_name(x, w))
    }

    fn diff_body(
        state: &mut DiffState,
        unit_a: &parser::Unit,
        a: &Self,
        unit_b: &parser::Unit,
        b: &Self,
    ) -> Result<()> {
        if state.options().print_source {
            state.field(
                "source",
                (unit_a, a),
                (unit_b, b),
                |w, _state, (unit, x)| print_source(x, w, unit),
            )?;
        }
        state.field("declaration", a, b, |w, state, x| {
            print_declaration(x, w, state)
        })?;
        state.field("size", a, b, |w, state, x| print_byte_size(x, w, state))?;
        print::inherit::diff_list(state, a.inherits(), b.inherits())?;
        state.field_expanded("members", |state| diff_members(state, unit_a, a, unit_b, b))
    }
}

fn print_source(ty: &StructType, w: &mut dyn ValuePrinter, unit: &Unit) -> Result<()> {
    print::source::print(ty.source(), w, unit)
}

fn print_byte_size(ty: &StructType, w: &mut dyn ValuePrinter, _hash: &FileHash) -> Result<()> {
    if let Some(size) = ty.byte_size() {
        write!(w, "{}", size)?;
    } else if !ty.is_declaration() {
        debug!("struct with no size");
    }
    Ok(())
}

fn print_declaration(ty: &StructType, w: &mut dyn ValuePrinter, _hash: &FileHash) -> Result<()> {
    if ty.is_declaration() {
        write!(w, "yes")?;
    }
    Ok(())
}

pub(crate) fn print_members(ty: &StructType, state: &mut PrintState, unit: &Unit) -> Result<()> {
    let layout = ty.layout(state.hash());
    state.list(unit, &layout)
}

pub(crate) fn diff_members(
    state: &mut DiffState,
    unit_a: &Unit,
    a: &StructType,
    unit_b: &Unit,
    b: &StructType,
) -> Result<()> {
    let layout_a = a.layout(state.hash_a());
    let layout_b = b.layout(state.hash_b());
    state.list(unit_a, &layout_a, unit_b, &layout_b)
}