lin-ldf 0.0.28

Parser for LDF files that describe automotive LIN bus networks.
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::ldf::ldf_comment::skip_whitespace;
use nom::{
    bytes::complete::{tag, take_while},
    IResult,
};

/// `Diagnostic_signals` section of a LIN Description File (LDF) for LIN 2.1
/// ```text
/// Diagnostic_signals {
///  MasterReqB0: 8, 0 ;
///  MasterReqB1: 8, 0 ;
///  MasterReqB2: 8, 0 ;
///  MasterReqB3: 8, 0 ;
///  MasterReqB4: 8, 0 ;
///  MasterReqB5: 8, 0 ;
///  MasterReqB6: 8, 0 ;
///  MasterReqB7: 8, 0 ;
///  SlaveRespB0: 8, 0 ;
///  SlaveRespB1: 8, 0 ;
///  SlaveRespB2: 8, 0 ;
///  SlaveRespB3: 8, 0 ;
///  SlaveRespB4: 8, 0 ;
///  SlaveRespB5: 8, 0 ;
///  SlaveRespB6: 8, 0 ;
///  SlaveRespB7: 8, 0 ;
/// }
/// ```

/// Diagnostic signal in the `Diagnostic_signals` section of a LIN Description File (LDF) for LIN 2.1
/// ```text
/// MasterReqB0: 8, 0 ;
/// ```
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct LdfDiagnosticSignal {
    /// All identifiers must be unique within the LDF file.
    pub name: String,

    /// Length of the signal in bits.
    pub length: u8,

    /// Initial value of the signal.
    pub init_value: u8,
}

pub fn parse_ldf_diagnostic_signals(s: &str) -> IResult<&str, Vec<LdfDiagnosticSignal>> {
    // `Diagnostic_signals {` or `Diagnostic_signals{` or ...
    // - May be any number of spaces before and after the "Diagnostic_signals" tag
    // - May be any number of spaces before and after the opening curly brace
    let (s, _) = skip_whitespace(s)?;

    // Assume that if the section label is not present, then the section is not present.
    if !s.starts_with("Diagnostic_signals") {
        return Ok((s, Vec::new()));
    }

    let (s, _) = tag("Diagnostic_signals")(s)?;
    let (s, _) = skip_whitespace(s)?;
    let (s, _) = tag("{")(s)?;
    let (s, _) = skip_whitespace(s)?;

    let mut diagnostic_signals = Vec::new();
    let mut remaining = s;

    while !remaining.starts_with('}') {
        // `MasterReqB0: 8, 0 ;` or `MasterReqB0: 8, 0;` or ...
        // - May be any number of spaces before and after the signal name
        // - May be any number of spaces before and after the colon
        // - May be any number of spaces before and after the signal size
        // - May be any number of spaces before and after the comma
        // - May be any number of spaces before and after the init value
        // - May be any number of spaces before and after the semicolon
        let (s, _) = skip_whitespace(remaining)?;
        let (s, signal_name) = take_while(|c: char| c.is_alphanumeric() || c == '_')(s)?;
        let (s, _) = skip_whitespace(s)?;
        let (s, _) = tag(":")(s)?;
        let (s, _) = skip_whitespace(s)?;
        let (s, signal_size) = take_while(|c: char| c.is_numeric())(s)?;
        let (s, _) = skip_whitespace(s)?;
        let (s, _) = tag(",")(s)?;
        let (s, _) = skip_whitespace(s)?;
        let (s, init_value) = take_while(|c: char| c.is_numeric())(s)?;
        let (s, _) = skip_whitespace(s)?;
        let (s, _) = tag(";")(s)?;
        let (s, _) = skip_whitespace(s)?;

        diagnostic_signals.push(LdfDiagnosticSignal {
            name: signal_name.to_string(),
            length: signal_size.parse().unwrap(),
            init_value: init_value.parse().unwrap(),
        });

        remaining = s;
    }

    let (remaining, _) = tag("}")(remaining)?;

    Ok((remaining, diagnostic_signals))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_ldf_diagnostic_signals() {
        let input = r#"
            Diagnostic_signals {
                MasterReqB0: 8, 0 ;
                MasterReqB1: 8, 0 ;
                MasterReqB2: 8, 0 ;
                MasterReqB3: 8, 0 ;
                MasterReqB4: 8, 0 ;
                MasterReqB5: 8, 0 ;
                MasterReqB6: 8, 0 ;
                MasterReqB7: 8, 0 ;
                SlaveRespB0: 8, 0 ;
                SlaveRespB1: 8, 0 ;
                SlaveRespB2: 8, 0 ;
                SlaveRespB3: 8, 0 ;
                SlaveRespB4: 8, 0 ;
                SlaveRespB5: 8, 0 ;
                SlaveRespB6: 8, 0 ;
                SlaveRespB7: 8, 0 ;
            }
        "#;

        let (_, diagnostic_signals) = parse_ldf_diagnostic_signals(input).unwrap();
        assert_eq!(diagnostic_signals.len(), 16);
        assert_eq!(diagnostic_signals[0].name, "MasterReqB0");
        assert_eq!(diagnostic_signals[0].length, 8);
        assert_eq!(diagnostic_signals[0].init_value, 0);

        assert_eq!(diagnostic_signals[15].name, "SlaveRespB7");
        assert_eq!(diagnostic_signals[15].length, 8);
        assert_eq!(diagnostic_signals[15].init_value, 0);
    }
}