1use 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
21pub fn parse(input: &str) -> Result<Dbc, DbcError> {
28 Parser::new(input).run()
29}
30
31#[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 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 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, 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 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 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 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 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 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 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 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 self.skip_to_semicolon()?;
262 }
263 "BA_DEF_" | "BA_DEF_DEF_" => {
264 self.bump(&Token::Word(keyword));
265 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 self.bump(&Token::Word(keyword));
288 self.skip_rest_of_line();
289 }
290 }
291 }
292 Ok(dbc)
293 }
294
295 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 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 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 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 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 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 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 message_id: Some(id & 0x1FFF_FFFF),
490 signal,
491 entries,
492 })
493 }
494
495 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 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 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 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
573fn 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 #![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 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 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 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 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 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}