Skip to main content

dbc_parse/
parser.rs

1//! The DBC grammar — a hand-rolled, total scanner for the Vector DBC
2//! format.
3//!
4//! Handles the core keyword set: `VERSION`, `NS_`, `BS_`, `BU_`, `BO_`,
5//! `SG_` (with `M` / `m<N>` multiplexing), `CM_` (multi-line quoted strings
6//! with `""` escapes), `VAL_`, `VAL_TABLE_`, `BA_`, `BA_DEF_`,
7//! `BA_DEF_DEF_`, and `SG_MUL_VAL_` (extended multiplexing). Unknown
8//! keywords are skipped line-wise rather than rejected — real-world DBC
9//! files carry vendor extensions — while malformed known constructs are
10//! typed [`DbcError::Syntax`] errors with line numbers.
11
12use crate::error::DbcError;
13use crate::model::{
14    Attribute, AttributeObject, AttributeValue, ByteOrder, CanId, Dbc, ExtendedMux, Message,
15    MultiplexingInfo, Node, Signal, ValueTable,
16};
17use alloc::format;
18use alloc::string::{String, ToString};
19use alloc::vec::Vec;
20
21/// Parses a full DBC document.
22///
23/// # Errors
24///
25/// [`DbcError::Syntax`] for malformed known constructs (with 1-based line
26/// numbers), [`DbcError::InvalidId`] for unrepresentable message ids.
27pub fn parse(input: &str) -> Result<Dbc, DbcError> {
28    Parser::new(input).run()
29}
30
31/// One lexical token. Words stop at whitespace or any punctuation character;
32/// quoted strings may span lines and use `""` as an escaped quote.
33#[derive(Debug, Clone, PartialEq)]
34enum Token<'a> {
35    Word(&'a str),
36    Quoted(String),
37    Punct(char),
38}
39
40struct Parser<'a> {
41    src: &'a str,
42    pos: usize,
43}
44
45impl<'a> Parser<'a> {
46    fn new(src: &'a str) -> Self {
47        Self { src, pos: 0 }
48    }
49
50    /// 1-based line of the current position (computed lazily, errors only).
51    fn line(&self) -> usize {
52        1 + self
53            .src
54            .as_bytes()
55            .iter()
56            .take(self.pos)
57            .filter(|byte| **byte == b'\n')
58            .count()
59    }
60
61    fn syntax(&self, message: &str) -> DbcError {
62        DbcError::Syntax {
63            line: self.line(),
64            message: message.to_string(),
65        }
66    }
67
68    fn skip_trivia(&mut self) {
69        while let Some(byte) = self.src.as_bytes().get(self.pos) {
70            if byte.is_ascii_whitespace() {
71                self.pos += 1;
72            } else {
73                break;
74            }
75        }
76    }
77
78    fn peek(&self) -> Option<Token<'a>> {
79        let rest = self.src.get(self.pos..)?;
80        let first = rest.as_bytes().first().copied()?;
81        if first == b'"' {
82            // Quoted strings are lexed whole on peek (cheap: bounded by the
83            // string itself); the scanner re-lexes on next().
84            let mut i = 1;
85            let bytes = rest.as_bytes();
86            while let Some(&byte) = bytes.get(i) {
87                match byte {
88                    b'"' if bytes.get(i + 1) == Some(&b'"') => i += 2, // "" escape
89                    b'"' => {
90                        let raw = rest.get(1..i)?;
91                        return Some(Token::Quoted(raw.replace("\"\"", "\"")));
92                    }
93                    _ => i += 1,
94                }
95            }
96            None
97        } else if is_punct(first) {
98            let ch = char::from(first);
99            Some(Token::Punct(ch))
100        } else if first.is_ascii_whitespace() {
101            None
102        } else {
103            let end = rest
104                .bytes()
105                .position(|byte| byte.is_ascii_whitespace() || is_punct(byte) || byte == b'"')
106                .unwrap_or(rest.len());
107            let word = rest.get(..end)?;
108            Some(Token::Word(word))
109        }
110    }
111
112    fn bump(&mut self, token: &Token<'a>) {
113        match token {
114            Token::Word(word) => self.pos += word.len(),
115            Token::Punct(_) => self.pos += 1,
116            // `+ 2` for the enclosing quotes; inner `""` pairs re-collapse
117            // to `"` so the raw span is (unescaped length) + 2.
118            Token::Quoted(quoted) => {
119                self.pos += quoted.len() + 2 + quoted.matches('"').count();
120            }
121        }
122    }
123
124    fn next(&mut self) -> Option<Token<'a>> {
125        self.skip_trivia();
126        let token = self.peek()?;
127        self.bump(&token);
128        Some(token)
129    }
130
131    /// Skips spaces and tabs — never newlines.
132    fn skip_spaces(&mut self) {
133        while matches!(self.src.as_bytes().get(self.pos), Some(b' ' | b'\t')) {
134            self.pos += 1;
135        }
136    }
137
138    /// Expects a word on the current line: like [`next`](Self::next), but
139    /// refuses to cross a newline (receiver lists, sender names).
140    fn next_on_line(&mut self) -> Option<Token<'a>> {
141        self.skip_spaces();
142        match self.src.as_bytes().get(self.pos) {
143            Some(b'\n' | b'\r') | None => None,
144            Some(_) => {
145                let token = self.peek()?;
146                self.bump(&token);
147                Some(token)
148            }
149        }
150    }
151
152    fn expect_word(&mut self, what: &str) -> Result<&'a str, DbcError> {
153        match self.next() {
154            Some(Token::Word(word)) => Ok(word),
155            other => Err(self.syntax(&format!("expected {what}, found {other:?}"))),
156        }
157    }
158
159    fn expect_punct(&mut self, ch: char) -> Result<(), DbcError> {
160        match self.next() {
161            Some(Token::Punct(found)) if found == ch => Ok(()),
162            other => Err(self.syntax(&format!("expected '{ch}', found {other:?}"))),
163        }
164    }
165
166    fn expect_quoted(&mut self, what: &str) -> Result<String, DbcError> {
167        match self.next() {
168            Some(Token::Quoted(quoted)) => Ok(quoted),
169            other => Err(self.syntax(&format!("expected {what} string, found {other:?}"))),
170        }
171    }
172
173    fn parse_num<T: core::str::FromStr>(&self, text: &str, what: &str) -> Result<T, DbcError> {
174        text.parse::<T>()
175            .map_err(|_| self.syntax(&format!("invalid {what}: {text:?}")))
176    }
177
178    /// Skips tokens until the statement-terminating `;` (quote-aware: the
179    /// scanner never splits a quoted string).
180    fn skip_to_semicolon(&mut self) -> Result<(), DbcError> {
181        loop {
182            match self.next() {
183                Some(Token::Punct(';')) => return Ok(()),
184                Some(_) => {}
185                None => return Err(self.syntax("expected ';' before end of file")),
186            }
187        }
188    }
189
190    /// Skips the remainder of the current line (unknown-keyword tolerance).
191    fn skip_rest_of_line(&mut self) {
192        if let Some(offset) = self.src.as_bytes().get(self.pos..).map(|rest| {
193            rest.iter()
194                .position(|byte| *byte == b'\n')
195                .unwrap_or(rest.len())
196        }) {
197            self.pos += offset;
198        }
199    }
200
201    fn run(mut self) -> Result<Dbc, DbcError> {
202        let mut dbc = Dbc::default();
203        loop {
204            self.skip_trivia();
205            let Some(Token::Word(keyword)) = self.peek() else {
206                // End of input, or a stray non-word byte.
207                if self.pos < self.src.len() {
208                    return Err(self.syntax("unexpected character at statement position"));
209                }
210                break;
211            };
212            match keyword {
213                "VERSION" => {
214                    self.bump(&Token::Word(keyword));
215                    dbc.version = Some(self.expect_quoted("version")?);
216                }
217                "NS_" => {
218                    self.bump(&Token::Word(keyword));
219                    // `NS_ :` opens a block of per-line keyword names that
220                    // ends at `BS_`.
221                    loop {
222                        self.skip_trivia();
223                        match self.peek() {
224                            Some(Token::Word("BS_")) => break,
225                            Some(_) => {
226                                self.next();
227                            }
228                            None => return Err(self.syntax("NS_ block not terminated by BS_")),
229                        }
230                    }
231                }
232                "BS_" => {
233                    self.bump(&Token::Word(keyword));
234                    self.expect_punct(':')?;
235                    self.skip_rest_of_line();
236                }
237                "BU_" => {
238                    self.bump(&Token::Word(keyword));
239                    self.expect_punct(':')?;
240                    while let Some(Token::Word(name)) = self.next_on_line() {
241                        dbc.nodes.push(Node {
242                            name: name.to_string(),
243                        });
244                    }
245                }
246                "BO_" => {
247                    self.bump(&Token::Word(keyword));
248                    dbc.messages.push(self.parse_message()?);
249                }
250                "SG_" => {
251                    self.bump(&Token::Word(keyword));
252                    let signal = self.parse_signal()?;
253                    let Some(message) = dbc.messages.last_mut() else {
254                        return Err(self.syntax("SG_ before any BO_"));
255                    };
256                    message.signals.push(signal);
257                }
258                "CM_" => {
259                    self.bump(&Token::Word(keyword));
260                    // `CM_ [BO_ id | SG_ id sig | BU_ node] "text" ;`
261                    self.skip_to_semicolon()?;
262                }
263                "BA_DEF_" | "BA_DEF_DEF_" => {
264                    self.bump(&Token::Word(keyword));
265                    // Attribute schema/default definitions are validated
266                    // (terminated) and skipped; the values live in BA_.
267                    self.skip_to_semicolon()?;
268                }
269                "BA_" => {
270                    self.bump(&Token::Word(keyword));
271                    dbc.attributes.push(self.parse_attribute()?);
272                }
273                "VAL_" => {
274                    self.bump(&Token::Word(keyword));
275                    dbc.value_tables.push(self.parse_value_table()?);
276                }
277                "VAL_TABLE_" => {
278                    self.bump(&Token::Word(keyword));
279                    dbc.value_tables.push(self.parse_val_table()?);
280                }
281                "SG_MUL_VAL_" => {
282                    self.bump(&Token::Word(keyword));
283                    dbc.extended_multiplexing.push(self.parse_sg_mul_val()?);
284                }
285                _ => {
286                    // Unknown keyword: tolerate and skip the line.
287                    self.bump(&Token::Word(keyword));
288                    self.skip_rest_of_line();
289                }
290            }
291        }
292        Ok(dbc)
293    }
294
295    /// `BO_ <id> <name>: <dlc> <sender>` followed by ` SG_` lines.
296    fn parse_message(&mut self) -> Result<Message, DbcError> {
297        let id_word = self.expect_word("message id")?;
298        let raw_id = self.parse_num::<u32>(id_word, "message id")?;
299        let id = CanId::from_dbc_raw(raw_id)?;
300        let name = self.expect_word("message name")?.to_string();
301        self.expect_punct(':')?;
302        let dlc_word = self.expect_word("message dlc")?;
303        let dlc = self.parse_num::<u8>(dlc_word, "message dlc")?;
304        if u32::from(dlc) > 64 {
305            return Err(self.syntax(&format!("message dlc {dlc} exceeds 64")));
306        }
307        let sender = match self.next_on_line() {
308            Some(Token::Word(sender)) => sender.to_string(),
309            Some(other) => return Err(self.syntax(&format!("expected sender, found {other:?}"))),
310            None => "Vector__XXX".to_string(),
311        };
312        Ok(Message {
313            id,
314            name,
315            dlc,
316            sender,
317            signals: Vec::new(),
318        })
319    }
320
321    /// `SG_ <name> [M | m<N>] : <start>|<len>@<order><sign> (<scale>,<offset>)
322    ///  [<min>|<max>] "<unit>" <recv1>,<recv2>`
323    fn parse_signal(&mut self) -> Result<Signal, DbcError> {
324        let name = self.expect_word("signal name")?.to_string();
325        self.skip_spaces();
326        let multiplexing_info = match self.peek() {
327            Some(Token::Word(word)) if word == "M" => {
328                self.bump(&Token::Word(word));
329                MultiplexingInfo::Multiplexor
330            }
331            Some(Token::Word(word))
332                if word.starts_with('m')
333                    && matches!(word.as_bytes().get(1), Some(digit) if digit.is_ascii_digit()) =>
334            {
335                self.bump(&Token::Word(word));
336                // `m<N>` or extended-multiplexing `m<N>M` — the value is
337                // what matters for extraction; `SG_MUL_VAL_` refines it.
338                let digits = word
339                    .strip_suffix('M')
340                    .unwrap_or(word)
341                    .strip_prefix('m')
342                    .unwrap_or(word);
343                let value = self.parse_num::<i32>(digits, "multiplex value")?;
344                MultiplexingInfo::Value(value)
345            }
346            _ => MultiplexingInfo::None,
347        };
348        self.expect_punct(':')?;
349        let start_word = self.expect_word("start bit")?;
350        let start_bit = self.parse_num::<u16>(start_word, "start bit")?;
351        if start_bit > 511 {
352            // A 64-byte payload numbers bits 0..=511.
353            return Err(self.syntax(&format!("start bit {start_bit} exceeds 511")));
354        }
355        self.expect_punct('|')?;
356        let len_word = self.expect_word("signal length")?;
357        let bit_length = self.parse_num::<u8>(len_word, "signal length")?;
358        if bit_length == 0 || bit_length > 64 {
359            return Err(self.syntax(&format!("signal length {bit_length} outside 1..=64")));
360        }
361        self.expect_punct('@')?;
362        let order_sign = self.expect_word("byte order/sign")?;
363        let order_bytes = order_sign.as_bytes();
364        let byte_order = match order_bytes.first() {
365            Some(b'0') => ByteOrder::Motorola,
366            Some(b'1') => ByteOrder::Intel,
367            _ => return Err(self.syntax(&format!("invalid byte order: {order_sign:?}"))),
368        };
369        let is_signed = match order_bytes.get(1) {
370            Some(b'-') => true,
371            Some(b'+') => false,
372            _ => return Err(self.syntax(&format!("invalid sign flag: {order_sign:?}"))),
373        };
374        self.expect_punct('(')?;
375        let scale_word = self.expect_word("scale")?;
376        let scale = self.parse_num::<f64>(scale_word, "scale")?;
377        if scale == 0.0 {
378            return Err(self.syntax("scale must be non-zero"));
379        }
380        self.expect_punct(',')?;
381        let offset_word = self.expect_word("offset")?;
382        let offset = self.parse_num::<f64>(offset_word, "offset")?;
383        self.expect_punct(')')?;
384        self.expect_punct('[')?;
385        let min_word = self.expect_word("minimum")?;
386        let min = self.parse_num::<f64>(min_word, "minimum")?;
387        self.expect_punct('|')?;
388        let max_word = self.expect_word("maximum")?;
389        let max = self.parse_num::<f64>(max_word, "maximum")?;
390        self.expect_punct(']')?;
391        let unit = self.expect_quoted("unit")?;
392        let receivers = self.parse_receivers()?;
393        Ok(Signal {
394            name,
395            start_bit,
396            bit_length,
397            byte_order,
398            is_signed,
399            scale,
400            offset,
401            min,
402            max,
403            unit,
404            receivers,
405            multiplexing_info,
406        })
407    }
408
409    /// Receiver list to end of line: `Node1,Node2` or `Vector__XXX`.
410    fn parse_receivers(&mut self) -> Result<Vec<String>, DbcError> {
411        let mut receivers = Vec::new();
412        let mut expect_name = true;
413        loop {
414            match self.next_on_line() {
415                Some(Token::Word(name)) if expect_name => {
416                    receivers.push(name.to_string());
417                    expect_name = false;
418                }
419                Some(Token::Punct(',')) if !expect_name => expect_name = true,
420                Some(other) => {
421                    return Err(self.syntax(&format!("in receiver list, found {other:?}")));
422                }
423                None => break,
424            }
425        }
426        if expect_name && !receivers.is_empty() {
427            return Err(self.syntax("receiver list ends with ','"));
428        }
429        Ok(receivers)
430    }
431
432    /// `BA_ "name" [BU_ node | BO_ id | SG_ id sig] <value> ;`
433    fn parse_attribute(&mut self) -> Result<Attribute, DbcError> {
434        let name = self.expect_quoted("attribute name")?;
435        self.skip_spaces();
436        let object = match self.peek() {
437            Some(Token::Word(word)) if word == "BU_" => {
438                self.bump(&Token::Word(word));
439                AttributeObject::Node(self.expect_word("node name")?.to_string())
440            }
441            Some(Token::Word(word)) if word == "BO_" => {
442                self.bump(&Token::Word(word));
443                let id_word = self.expect_word("message id")?;
444                let id = self.parse_num::<u32>(id_word, "message id")?;
445                AttributeObject::Message(id & 0x1FFF_FFFF)
446            }
447            Some(Token::Word(word)) if word == "SG_" => {
448                self.bump(&Token::Word(word));
449                let id_word = self.expect_word("message id")?;
450                let id = self.parse_num::<u32>(id_word, "message id")?;
451                let signal = self.expect_word("signal name")?.to_string();
452                AttributeObject::Signal {
453                    message_id: id & 0x1FFF_FFFF,
454                    signal,
455                }
456            }
457            _ => AttributeObject::Database,
458        };
459        let value = match self.next() {
460            Some(Token::Quoted(quoted)) => AttributeValue::Str(quoted),
461            Some(Token::Word(word)) => {
462                if let Ok(int) = word.parse::<i64>() {
463                    AttributeValue::Int(int)
464                } else {
465                    AttributeValue::Float(self.parse_num::<f64>(word, "attribute value")?)
466                }
467            }
468            other => {
469                return Err(self.syntax(&format!("expected attribute value, found {other:?}")));
470            }
471        };
472        self.expect_punct(';')?;
473        Ok(Attribute {
474            name,
475            object,
476            value,
477        })
478    }
479
480    /// `VAL_ <id> <signal> (<num> "label")* ;`
481    fn parse_value_table(&mut self) -> Result<ValueTable, DbcError> {
482        let id_word = self.expect_word("message id")?;
483        let id = self.parse_num::<u32>(id_word, "message id")?;
484        let signal = self.expect_word("signal name")?.to_string();
485        let entries = self.parse_table_entries()?;
486        Ok(ValueTable {
487            name: None,
488            // Stored without the extended-flag bit, matching CanId::raw().
489            message_id: Some(id & 0x1FFF_FFFF),
490            signal,
491            entries,
492        })
493    }
494
495    /// `VAL_TABLE_ <name> (<num> "label")* ;`
496    fn parse_val_table(&mut self) -> Result<ValueTable, DbcError> {
497        let name = self.expect_word("table name")?.to_string();
498        let entries = self.parse_table_entries()?;
499        Ok(ValueTable {
500            name: Some(name),
501            message_id: None,
502            signal: String::new(),
503            entries,
504        })
505    }
506
507    /// `(num "label")*` until the terminating `;`.
508    fn parse_table_entries(&mut self) -> Result<Vec<(i64, String)>, DbcError> {
509        let mut entries = Vec::new();
510        loop {
511            self.skip_trivia();
512            match self.peek() {
513                Some(Token::Punct(';')) => {
514                    self.bump(&Token::Punct(';'));
515                    return Ok(entries);
516                }
517                Some(Token::Word(word)) => {
518                    self.bump(&Token::Word(word));
519                    let raw = self.parse_num::<i64>(word, "table entry value")?;
520                    let label = self.expect_quoted("table entry label")?;
521                    entries.push((raw, label));
522                }
523                other => {
524                    return Err(
525                        self.syntax(&format!("expected table entry or ';', found {other:?}"))
526                    );
527                }
528            }
529        }
530    }
531
532    /// `SG_MUL_VAL_ <id> <signal> <selector> <a-b, c-d> ;`
533    fn parse_sg_mul_val(&mut self) -> Result<ExtendedMux, DbcError> {
534        let id_word = self.expect_word("message id")?;
535        let message_id = self.parse_num::<u32>(id_word, "message id")?;
536        let signal = self.expect_word("signal name")?.to_string();
537        let selector = self.expect_word("selector signal")?.to_string();
538        let mut ranges = Vec::new();
539        loop {
540            self.skip_trivia();
541            match self.peek() {
542                Some(Token::Punct(';')) => {
543                    self.bump(&Token::Punct(';'));
544                    return Ok(ExtendedMux {
545                        // Stored without the extended-flag bit, matching
546                        // CanId::raw().
547                        message_id: message_id & 0x1FFF_FFFF,
548                        signal,
549                        selector,
550                        ranges,
551                    });
552                }
553                Some(Token::Punct(',')) => {
554                    self.bump(&Token::Punct(','));
555                }
556                Some(Token::Word(word)) => {
557                    self.bump(&Token::Word(word));
558                    let Some((from, to)) = word.split_once('-') else {
559                        return Err(self.syntax(&format!("invalid mux range: {word:?}")));
560                    };
561                    let from = self.parse_num::<i32>(from, "mux range start")?;
562                    let to = self.parse_num::<i32>(to, "mux range end")?;
563                    ranges.push((from, to));
564                }
565                other => {
566                    return Err(self.syntax(&format!("expected mux range or ';', found {other:?}")));
567                }
568            }
569        }
570    }
571}
572
573/// Punctuation that terminates a word in DBC grammar.
574fn is_punct(byte: u8) -> bool {
575    matches!(
576        byte,
577        b':' | b'|' | b'@' | b'(' | b')' | b'[' | b']' | b',' | b';'
578    )
579}
580
581#[cfg(test)]
582mod tests {
583    // Tests exercise edge values and index fixed-size buffers directly:
584    // unwrap/expect/indexing/panic are lifted at test scope by design.
585    #![allow(
586        clippy::unwrap_used,
587        clippy::expect_used,
588        clippy::indexing_slicing,
589        clippy::panic
590    )]
591    use super::*;
592
593    #[test]
594    fn quoted_string_escapes() {
595        let mut p = Parser::new(r#""say ""hi"" now""#);
596        assert_eq!(p.expect_quoted("x").unwrap(), r#"say "hi" now"#);
597    }
598
599    #[test]
600    fn unterminated_string_is_none() {
601        let mut p = Parser::new("\"no closing quote");
602        assert!(p.next().is_none());
603    }
604
605    #[test]
606    fn words_stop_at_punct() {
607        let mut p = Parser::new("7|16@0-");
608        assert_eq!(p.next(), Some(Token::Word("7")));
609        assert_eq!(p.next(), Some(Token::Punct('|')));
610        assert_eq!(p.next(), Some(Token::Word("16")));
611        assert_eq!(p.next(), Some(Token::Punct('@')));
612        assert_eq!(p.next(), Some(Token::Word("0-")));
613    }
614
615    #[test]
616    fn next_on_line_respects_newline() {
617        let mut p = Parser::new("PCM1,FOO\nBU_:");
618        assert_eq!(p.next_on_line(), Some(Token::Word("PCM1")));
619        assert_eq!(p.next_on_line(), Some(Token::Punct(',')));
620        assert_eq!(p.next_on_line(), Some(Token::Word("FOO")));
621        assert_eq!(p.next_on_line(), None);
622    }
623
624    #[test]
625    fn syntax_errors_carry_line_numbers() {
626        let error = parse("BO_ nope Bad: 8 X\n").unwrap_err();
627        match error {
628            DbcError::Syntax { line, message } => {
629                assert_eq!(line, 1);
630                assert!(message.contains("message id"), "{message}");
631            }
632            other => panic!("expected Syntax, got {other:?}"),
633        }
634    }
635
636    #[test]
637    fn signal_constraints_are_checked() {
638        // Zero scale:
639        let error = parse("BO_ 1 M: 8 S\n SG_ A : 0|8@1+ (0,0) [0|0] \"\" X\n").unwrap_err();
640        assert!(matches!(error, DbcError::Syntax { .. }));
641        // Zero length:
642        let error = parse("BO_ 1 M: 8 S\n SG_ A : 0|0@1+ (1,0) [0|0] \"\" X\n").unwrap_err();
643        assert!(matches!(error, DbcError::Syntax { .. }));
644        // Start bit beyond the 512-bit FD payload space:
645        let error = parse("BO_ 1 M: 8 S\n SG_ A : 512|8@1+ (1,0) [0|0] \"\" X\n").unwrap_err();
646        assert!(matches!(error, DbcError::Syntax { .. }));
647        // SG_ before BO_:
648        let error = parse(" SG_ A : 0|8@1+ (1,0) [0|0] \"\" X\n").unwrap_err();
649        assert!(matches!(error, DbcError::Syntax { .. }));
650    }
651
652    #[test]
653    fn unknown_keywords_are_skipped() {
654        let dbc =
655            parse("VENDOR \"acme\"\nBO_ 5 Msg: 1 Node\nSG_ A : 7|8@0+ (1,0) [0|255] \"\" X\n")
656                .unwrap();
657        assert_eq!(dbc.messages.len(), 1);
658    }
659
660    #[test]
661    fn invalid_ids_are_rejected() {
662        // Plain id above the 11-bit standard width without the extended bit:
663        let error = parse("BO_ 2048 Bad: 1 X\n").unwrap_err();
664        assert!(matches!(
665            error,
666            DbcError::InvalidId {
667                raw: 2048,
668                max: 0x7FF
669            }
670        ));
671    }
672}