can_dbc/
parser.rs

1//!
2//! Module containing nom parser combinators
3//!
4
5use std::str;
6
7use nom::branch::{alt, permutation};
8use nom::bytes::complete::{escaped, tag, take_till, take_till1, take_while, take_while1};
9use nom::character::complete::{self, char, line_ending, multispace0, one_of, space0, space1};
10use nom::combinator::{map, opt, value};
11use nom::error::{ErrorKind, ParseError};
12use nom::multi::{many0, many_till, separated_list0};
13use nom::number::complete::double;
14use nom::sequence::preceded;
15use nom::{AsChar, IResult, Input, Parser};
16
17use crate::{
18    AccessNode, AccessType, AttributeDefault, AttributeDefinition, AttributeValue,
19    AttributeValueForObject, AttributeValuedForObjectType, Baudrate, ByteOrder, Comment, Dbc,
20    EnvType, EnvironmentVariable, EnvironmentVariableData, ExtendedMultiplex,
21    ExtendedMultiplexMapping, Message, MessageId, MessageTransmitter, MultiplexIndicator, Node,
22    Signal, SignalExtendedValueType, SignalExtendedValueTypeList, SignalGroups, SignalType,
23    SignalTypeRef, Symbol, Transmitter, ValDescription, ValueDescription, ValueTable, ValueType,
24    Version,
25};
26
27fn is_semi_colon(chr: char) -> bool {
28    chr == ';'
29}
30
31fn is_c_string_char(chr: char) -> bool {
32    chr.is_ascii_digit() || chr.is_alphabetic() || chr == '_'
33}
34
35fn is_c_ident_head(chr: char) -> bool {
36    chr.is_alphabetic() || chr == '_'
37}
38
39fn is_quote_or_escape_character(chr: char) -> bool {
40    chr == '"' || chr == '\\'
41}
42
43/// Multispace zero or more
44fn ms0<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
45where
46    T: Input,
47    <T as Input>::Item: AsChar + Clone,
48{
49    input.split_at_position_complete(|item| {
50        let c = item.as_char();
51        c != ' '
52    })
53}
54
55/// Multi space one or more
56fn ms1<T, E: ParseError<T>>(input: T) -> IResult<T, T, E>
57where
58    T: Input,
59    <T as Input>::Item: AsChar + Clone,
60{
61    input.split_at_position1_complete(
62        |item| {
63            let c = item.as_char();
64            c != ' '
65        },
66        ErrorKind::MultiSpace,
67    )
68}
69
70/// Colon aka `:`
71fn colon(s: &str) -> IResult<&str, char> {
72    char(':').parse(s)
73}
74
75/// Comma aka ','
76fn comma(s: &str) -> IResult<&str, char> {
77    char(',').parse(s)
78}
79
80/// Comma aka ';'
81fn semi_colon(s: &str) -> IResult<&str, char> {
82    char(';').parse(s)
83}
84
85/// Quote aka '"'
86fn quote(s: &str) -> IResult<&str, char> {
87    char('"').parse(s)
88}
89
90/// Pipe character
91fn pipe(s: &str) -> IResult<&str, char> {
92    char('|').parse(s)
93}
94
95/// at character
96fn at(s: &str) -> IResult<&str, char> {
97    char('@').parse(s)
98}
99
100/// brace open aka '('
101fn brc_open(s: &str) -> IResult<&str, char> {
102    char('(').parse(s)
103}
104
105/// brace close aka ')'
106fn brc_close(s: &str) -> IResult<&str, char> {
107    char(')').parse(s)
108}
109
110/// bracket open aka '['
111fn brk_open(s: &str) -> IResult<&str, char> {
112    char('[').parse(s)
113}
114
115/// bracket close aka ']'
116fn brk_close(s: &str) -> IResult<&str, char> {
117    char(']').parse(s)
118}
119
120/// A valid `C_identifier`. `C_identifier`s start with an alpha character or an underscore
121/// and may further consist of alphanumeric characters and underscore
122fn c_ident(s: &str) -> IResult<&str, String> {
123    let (s, head) = take_while1(is_c_ident_head).parse(s)?;
124    let (s, remaining) = take_while(is_c_string_char).parse(s)?;
125    Ok((s, [head, remaining].concat()))
126}
127
128fn c_ident_vec(s: &str) -> IResult<&str, Vec<String>> {
129    separated_list0(comma, c_ident).parse(s)
130}
131
132fn char_string(s: &str) -> IResult<&str, &str> {
133    let (s, _) = quote(s)?;
134    let (s, optional_char_string_value) = opt(escaped(
135        take_till1(is_quote_or_escape_character),
136        '\\',
137        one_of(r#""n\"#),
138    ))
139    .parse(s)?;
140    let (s, _) = quote(s)?;
141
142    let char_string_value = optional_char_string_value.unwrap_or("");
143    Ok((s, char_string_value))
144}
145
146fn little_endian(s: &str) -> IResult<&str, ByteOrder> {
147    map(char('1'), |_| ByteOrder::LittleEndian).parse(s)
148}
149
150fn big_endian(s: &str) -> IResult<&str, ByteOrder> {
151    map(char('0'), |_| ByteOrder::BigEndian).parse(s)
152}
153
154fn byte_order(s: &str) -> IResult<&str, ByteOrder> {
155    alt((little_endian, big_endian)).parse(s)
156}
157
158fn message_id(s: &str) -> IResult<&str, MessageId> {
159    let (s, parsed_value) = complete::u32(s)?;
160
161    if parsed_value & (1 << 31) != 0 {
162        Ok((s, MessageId::Extended(parsed_value & 0x1FFF_FFFF)))
163    } else {
164        // FIXME: use u16::try_from and handle error
165        #[allow(clippy::cast_possible_truncation)]
166        Ok((s, MessageId::Standard(parsed_value as u16)))
167    }
168}
169
170fn signed(s: &str) -> IResult<&str, ValueType> {
171    map(char('-'), |_| ValueType::Signed).parse(s)
172}
173
174fn unsigned(s: &str) -> IResult<&str, ValueType> {
175    map(char('+'), |_| ValueType::Unsigned).parse(s)
176}
177
178fn value_type(s: &str) -> IResult<&str, ValueType> {
179    alt((signed, unsigned)).parse(s)
180}
181
182fn multiplexer(s: &str) -> IResult<&str, MultiplexIndicator> {
183    let (s, _) = ms1(s)?;
184    let (s, _) = char('m').parse(s)?;
185    let (s, d) = complete::u64(s)?;
186    let (s, _) = ms1(s)?;
187    Ok((s, MultiplexIndicator::MultiplexedSignal(d)))
188}
189
190fn multiplexor(s: &str) -> IResult<&str, MultiplexIndicator> {
191    let (s, _) = ms1(s)?;
192    let (s, _) = char('M').parse(s)?;
193    let (s, _) = ms1(s)?;
194    Ok((s, MultiplexIndicator::Multiplexor))
195}
196
197fn multiplexor_and_multiplexed(s: &str) -> IResult<&str, MultiplexIndicator> {
198    let (s, _) = ms1(s)?;
199    let (s, _) = char('m').parse(s)?;
200    let (s, d) = complete::u64(s)?;
201    let (s, _) = char('M').parse(s)?;
202    let (s, _) = ms1(s)?;
203    Ok((s, MultiplexIndicator::MultiplexorAndMultiplexedSignal(d)))
204}
205
206fn plain(s: &str) -> IResult<&str, MultiplexIndicator> {
207    let (s, _) = ms1(s)?;
208    Ok((s, MultiplexIndicator::Plain))
209}
210
211fn multiplexer_indicator(s: &str) -> IResult<&str, MultiplexIndicator> {
212    alt((multiplexer, multiplexor, multiplexor_and_multiplexed, plain)).parse(s)
213}
214
215fn version(s: &str) -> IResult<&str, Version> {
216    let (s, _) = multispace0(s)?;
217    let (s, _) = tag("VERSION").parse(s)?;
218    let (s, _) = ms1(s)?;
219    let (s, v) = char_string(s)?;
220    let (s, _) = line_ending(s)?;
221    Ok((s, Version(v.to_string())))
222}
223
224fn bit_timing(s: &str) -> IResult<&str, Vec<Baudrate>> {
225    let (s, _) = multispace0(s)?;
226    let (s, _) = tag("BS_:").parse(s)?;
227    let (s, baudrates) = opt(preceded(
228        ms1,
229        separated_list0(comma, map(complete::u64, Baudrate)),
230    ))
231    .parse(s)?;
232    Ok((s, baudrates.unwrap_or_default()))
233}
234
235fn signal(s: &str) -> IResult<&str, Signal> {
236    let (s, _) = multispace0(s)?;
237    let (s, _) = tag("SG_").parse(s)?;
238    let (s, _) = ms1(s)?;
239    let (s, name) = c_ident(s)?;
240    let (s, multiplexer_indicator) = multiplexer_indicator(s)?;
241    let (s, _) = colon(s)?;
242    let (s, _) = ms1(s)?;
243    let (s, start_bit) = complete::u64(s)?;
244    let (s, _) = pipe(s)?;
245    let (s, signal_size) = complete::u64(s)?;
246    let (s, _) = at(s)?;
247    let (s, byte_order) = byte_order(s)?;
248    let (s, value_type) = value_type(s)?;
249    let (s, _) = ms1(s)?;
250    let (s, _) = brc_open(s)?;
251    let (s, factor) = double(s)?;
252    let (s, _) = comma(s)?;
253    let (s, offset) = double(s)?;
254    let (s, _) = brc_close(s)?;
255    let (s, _) = ms1(s)?;
256    let (s, _) = brk_open(s)?;
257    let (s, min) = double(s)?;
258    let (s, _) = pipe(s)?;
259    let (s, max) = double(s)?;
260    let (s, _) = brk_close(s)?;
261    let (s, _) = ms1(s)?;
262    let (s, unit) = char_string(s)?;
263    let (s, _) = ms1(s)?;
264    let (s, receivers) = c_ident_vec(s)?;
265    let (s, _) = line_ending(s)?;
266    Ok((
267        s,
268        Signal {
269            name,
270            multiplexer_indicator,
271            start_bit,
272            size: signal_size,
273            byte_order,
274            value_type,
275            factor,
276            offset,
277            min,
278            max,
279            unit: unit.to_string(),
280            receivers,
281        },
282    ))
283}
284
285fn message(s: &str) -> IResult<&str, Message> {
286    let (s, _) = multispace0(s)?;
287    let (s, _) = tag("BO_").parse(s)?;
288    let (s, _) = ms1(s)?;
289    let (s, message_id) = message_id(s)?;
290    let (s, _) = ms1(s)?;
291    let (s, message_name) = c_ident(s)?;
292    let (s, _) = colon(s)?;
293    let (s, _) = ms1(s)?;
294    let (s, message_size) = complete::u64(s)?;
295    let (s, _) = ms1(s)?;
296    let (s, transmitter) = transmitter(s)?;
297    let (s, signals) = many0(signal).parse(s)?;
298    Ok((
299        s,
300        (Message {
301            id: message_id,
302            name: message_name,
303            size: message_size,
304            transmitter,
305            signals,
306        }),
307    ))
308}
309
310fn attribute_default(s: &str) -> IResult<&str, AttributeDefault> {
311    let (s, _) = multispace0(s)?;
312    let (s, _) = tag("BA_DEF_DEF_").parse(s)?;
313    let (s, _) = ms1(s)?;
314    let (s, attribute_name) = char_string(s)?;
315    let (s, _) = ms1(s)?;
316    let (s, attribute_value) = attribute_value(s)?;
317    let (s, _) = semi_colon(s)?;
318    let (s, _) = line_ending(s)?;
319
320    Ok((
321        s,
322        AttributeDefault {
323            name: attribute_name.to_string(),
324            value: attribute_value,
325        },
326    ))
327}
328
329fn node_comment(s: &str) -> IResult<&str, Comment> {
330    let (s, _) = tag("BU_").parse(s)?;
331    let (s, _) = ms1(s)?;
332    let (s, node_name) = c_ident(s)?;
333    let (s, _) = ms1(s)?;
334    let (s, comment) = char_string(s)?;
335
336    Ok((
337        s,
338        Comment::Node {
339            name: node_name,
340            comment: comment.to_string(),
341        },
342    ))
343}
344
345fn message_comment(s: &str) -> IResult<&str, Comment> {
346    let (s, _) = tag("BO_").parse(s)?;
347    let (s, _) = ms1(s)?;
348    let (s, message_id) = message_id(s)?;
349    let (s, _) = ms1(s)?;
350    let (s, comment) = char_string(s)?;
351
352    Ok((
353        s,
354        Comment::Message {
355            id: message_id,
356            comment: comment.to_string(),
357        },
358    ))
359}
360
361fn signal_comment(s: &str) -> IResult<&str, Comment> {
362    let (s, _) = tag("SG_").parse(s)?;
363    let (s, _) = ms1(s)?;
364    let (s, message_id) = message_id(s)?;
365    let (s, _) = ms1(s)?;
366    let (s, signal_name) = c_ident(s)?;
367    let (s, _) = ms1(s)?;
368    let (s, comment) = char_string(s)?;
369    Ok((
370        s,
371        Comment::Signal {
372            message_id,
373            name: signal_name,
374            comment: comment.to_string(),
375        },
376    ))
377}
378
379fn env_var_comment(s: &str) -> IResult<&str, Comment> {
380    let (s, _) = ms0(s)?;
381    let (s, _) = tag("EV_").parse(s)?;
382    let (s, _) = ms1(s)?;
383    let (s, env_var_name) = c_ident(s)?;
384    let (s, _) = ms1(s)?;
385    let (s, comment) = char_string(s)?;
386    Ok((
387        s,
388        Comment::EnvVar {
389            name: env_var_name,
390            comment: comment.to_string(),
391        },
392    ))
393}
394
395fn comment_plain(s: &str) -> IResult<&str, Comment> {
396    let (s, comment) = char_string(s)?;
397    Ok((
398        s,
399        Comment::Plain {
400            comment: comment.to_string(),
401        },
402    ))
403}
404
405fn comment(s: &str) -> IResult<&str, Comment> {
406    let (s, _) = multispace0(s)?;
407    let (s, _) = tag("CM_").parse(s)?;
408    let (s, _) = ms1(s)?;
409    let (s, comment) = alt((
410        node_comment,
411        message_comment,
412        env_var_comment,
413        signal_comment,
414        comment_plain,
415    ))
416    .parse(s)?;
417    let (s, _) = semi_colon(s)?;
418    let (s, _) = line_ending(s)?;
419    Ok((s, comment))
420}
421
422fn value_description(s: &str) -> IResult<&str, ValDescription> {
423    let (s, a) = double(s)?;
424    let (s, _) = ms1(s)?;
425    let (s, b) = char_string(s)?;
426    Ok((
427        s,
428        ValDescription {
429            id: a,
430            description: b.to_string(),
431        },
432    ))
433}
434
435fn value_description_for_signal(s: &str) -> IResult<&str, ValueDescription> {
436    let (s, _) = ms0(s)?;
437    let (s, _) = tag("VAL_").parse(s)?;
438    let (s, _) = ms1(s)?;
439    let (s, message_id) = message_id(s)?;
440    let (s, _) = ms1(s)?;
441    let (s, signal_name) = c_ident(s)?;
442    let (s, value_descriptions) = many_till(
443        preceded(ms1, value_description),
444        preceded(opt(ms1), semi_colon),
445    )
446    .parse(s)?;
447    Ok((
448        s,
449        ValueDescription::Signal {
450            message_id,
451            name: signal_name,
452            value_descriptions: value_descriptions.0,
453        },
454    ))
455}
456
457fn value_description_for_env_var(s: &str) -> IResult<&str, ValueDescription> {
458    let (s, _) = ms0(s)?;
459    let (s, _) = tag("VAL_").parse(s)?;
460    let (s, _) = ms1(s)?;
461    let (s, env_var_name) = c_ident(s)?;
462    let (s, value_descriptions) = many_till(
463        preceded(ms1, value_description),
464        preceded(opt(ms1), semi_colon),
465    )
466    .parse(s)?;
467    Ok((
468        s,
469        ValueDescription::EnvironmentVariable {
470            name: env_var_name,
471            value_descriptions: value_descriptions.0,
472        },
473    ))
474}
475
476fn value_descriptions(s: &str) -> IResult<&str, ValueDescription> {
477    let (s, _) = multispace0(s)?;
478    let (s, vd) = alt((value_description_for_signal, value_description_for_env_var)).parse(s)?;
479    let (s, _) = line_ending(s)?;
480    Ok((s, vd))
481}
482
483fn env_float(s: &str) -> IResult<&str, EnvType> {
484    value(EnvType::Float, char('0')).parse(s)
485}
486
487fn env_int(s: &str) -> IResult<&str, EnvType> {
488    value(EnvType::U64, char('1')).parse(s)
489}
490
491fn env_data(s: &str) -> IResult<&str, EnvType> {
492    value(EnvType::U64, char('2')).parse(s)
493}
494
495fn env_var_type(s: &str) -> IResult<&str, EnvType> {
496    alt((env_float, env_int, env_data)).parse(s)
497}
498
499fn dummy_node_vector_0(s: &str) -> IResult<&str, AccessType> {
500    value(AccessType::DummyNodeVector0, char('0')).parse(s)
501}
502
503fn dummy_node_vector_1(s: &str) -> IResult<&str, AccessType> {
504    value(AccessType::DummyNodeVector1, char('1')).parse(s)
505}
506
507fn dummy_node_vector_2(s: &str) -> IResult<&str, AccessType> {
508    value(AccessType::DummyNodeVector2, char('2')).parse(s)
509}
510fn dummy_node_vector_3(s: &str) -> IResult<&str, AccessType> {
511    value(AccessType::DummyNodeVector3, char('3')).parse(s)
512}
513
514fn access_type(s: &str) -> IResult<&str, AccessType> {
515    let (s, _) = tag("DUMMY_NODE_VECTOR").parse(s)?;
516    let (s, node) = alt((
517        dummy_node_vector_0,
518        dummy_node_vector_1,
519        dummy_node_vector_2,
520        dummy_node_vector_3,
521    ))
522    .parse(s)?;
523    Ok((s, node))
524}
525
526fn access_node_vector_xxx(s: &str) -> IResult<&str, AccessNode> {
527    value(AccessNode::VectorXXX, tag("VECTOR_XXX")).parse(s)
528}
529
530fn access_node_name(s: &str) -> IResult<&str, AccessNode> {
531    map(c_ident, AccessNode::Name).parse(s)
532}
533
534fn access_node(s: &str) -> IResult<&str, AccessNode> {
535    alt((access_node_vector_xxx, access_node_name)).parse(s)
536}
537
538/// Environment Variable Definitions
539fn environment_variable(s: &str) -> IResult<&str, EnvironmentVariable> {
540    let (s, _) = multispace0(s)?;
541    let (s, _) = tag("EV_").parse(s)?;
542    let (s, _) = ms1(s)?;
543    let (s, env_var_name) = c_ident(s)?;
544    let (s, _) = colon(s)?;
545    let (s, _) = ms1(s)?;
546    let (s, env_var_type) = env_var_type(s)?;
547    let (s, _) = ms1(s)?;
548    let (s, _) = brk_open(s)?;
549    let (s, min) = complete::i64(s)?;
550    let (s, _) = pipe(s)?;
551    let (s, max) = complete::i64(s)?;
552    let (s, _) = brk_close(s)?;
553    let (s, _) = ms1(s)?;
554    let (s, unit) = char_string(s)?;
555    let (s, _) = ms1(s)?;
556    let (s, initial_value) = double(s)?;
557    let (s, _) = ms1(s)?;
558    let (s, ev_id) = complete::i64(s)?;
559    let (s, _) = ms1(s)?;
560    let (s, access_type) = access_type(s)?;
561    let (s, _) = ms1(s)?;
562    let (s, access_nodes) = separated_list0(comma, access_node).parse(s)?;
563    let (s, _) = semi_colon(s)?;
564    let (s, _) = line_ending(s)?;
565    Ok((
566        s,
567        EnvironmentVariable {
568            name: env_var_name,
569            typ: env_var_type,
570            min,
571            max,
572            unit: unit.to_string(),
573            initial_value,
574            ev_id,
575            access_type,
576            access_nodes,
577        },
578    ))
579}
580
581fn environment_variable_data(s: &str) -> IResult<&str, EnvironmentVariableData> {
582    let (s, _) = multispace0(s)?;
583    let (s, _) = tag("ENVVAR_DATA_").parse(s)?;
584    let (s, _) = ms1(s)?;
585    let (s, env_var_name) = c_ident(s)?;
586    let (s, _) = colon(s)?;
587    let (s, _) = ms1(s)?;
588    let (s, data_size) = complete::u64(s)?;
589    let (s, _) = semi_colon(s)?;
590    let (s, _) = line_ending(s)?;
591    Ok((
592        s,
593        EnvironmentVariableData {
594            env_var_name,
595            data_size,
596        },
597    ))
598}
599
600fn signal_type(s: &str) -> IResult<&str, SignalType> {
601    let (s, _) = multispace0(s)?;
602    let (s, _) = tag("SGTYPE_").parse(s)?;
603    let (s, _) = ms1(s)?;
604    let (s, signal_type_name) = c_ident(s)?;
605    let (s, _) = colon(s)?;
606    let (s, _) = ms1(s)?;
607    let (s, signal_size) = complete::u64(s)?;
608    let (s, _) = at(s)?;
609    let (s, byte_order) = byte_order(s)?;
610    let (s, value_type) = value_type(s)?;
611    let (s, _) = ms1(s)?;
612    let (s, _) = brc_open(s)?;
613    let (s, factor) = double(s)?;
614    let (s, _) = comma(s)?;
615    let (s, offset) = double(s)?;
616    let (s, _) = brc_close(s)?;
617    let (s, _) = ms1(s)?;
618    let (s, _) = brk_open(s)?;
619    let (s, min) = double(s)?;
620    let (s, _) = pipe(s)?;
621    let (s, max) = double(s)?;
622    let (s, _) = brk_close(s)?;
623    let (s, _) = ms1(s)?;
624    let (s, unit) = char_string(s)?;
625    let (s, _) = ms1(s)?;
626    let (s, default_value) = double(s)?;
627    let (s, _) = ms1(s)?;
628    let (s, value_table) = c_ident(s)?;
629    let (s, _) = semi_colon(s)?;
630    let (s, _) = line_ending(s)?;
631    Ok((
632        s,
633        SignalType {
634            name: signal_type_name,
635            signal_size,
636            byte_order,
637            value_type,
638            factor,
639            offset,
640            min,
641            max,
642            unit: unit.to_string(),
643            default_value,
644            value_table,
645        },
646    ))
647}
648
649#[allow(dead_code)]
650fn attribute_value_uint64(s: &str) -> IResult<&str, AttributeValue> {
651    map(complete::u64, AttributeValue::U64).parse(s)
652}
653
654#[allow(dead_code)]
655fn attribute_value_int64(s: &str) -> IResult<&str, AttributeValue> {
656    map(complete::i64, AttributeValue::I64).parse(s)
657}
658
659fn attribute_value_f64(s: &str) -> IResult<&str, AttributeValue> {
660    map(double, AttributeValue::Double).parse(s)
661}
662
663fn attribute_value_charstr(s: &str) -> IResult<&str, AttributeValue> {
664    map(char_string, |x| AttributeValue::String(x.to_string())).parse(s)
665}
666
667fn attribute_value(s: &str) -> IResult<&str, AttributeValue> {
668    alt((
669        // attribute_value_uint64,
670        // attribute_value_int64,
671        attribute_value_f64,
672        attribute_value_charstr,
673    ))
674    .parse(s)
675}
676
677fn network_node_attribute_value(s: &str) -> IResult<&str, AttributeValuedForObjectType> {
678    let (s, _) = tag("BU_").parse(s)?;
679    let (s, _) = ms1(s)?;
680    let (s, node_name) = c_ident(s)?;
681    let (s, _) = ms1(s)?;
682    let (s, value) = attribute_value(s)?;
683    Ok((
684        s,
685        AttributeValuedForObjectType::NetworkNode(node_name, value),
686    ))
687}
688
689fn message_definition_attribute_value(s: &str) -> IResult<&str, AttributeValuedForObjectType> {
690    let (s, _) = tag("BO_").parse(s)?;
691    let (s, _) = ms1(s)?;
692    let (s, message_id) = message_id(s)?;
693    let (s, _) = ms1(s)?;
694    let (s, value) = opt(attribute_value).parse(s)?;
695    Ok((
696        s,
697        AttributeValuedForObjectType::MessageDefinition(message_id, value),
698    ))
699}
700
701fn signal_attribute_value(s: &str) -> IResult<&str, AttributeValuedForObjectType> {
702    let (s, _) = tag("SG_").parse(s)?;
703    let (s, _) = ms1(s)?;
704    let (s, message_id) = message_id(s)?;
705    let (s, _) = ms1(s)?;
706    let (s, signal_name) = c_ident(s)?;
707    let (s, _) = ms1(s)?;
708    let (s, value) = attribute_value(s)?;
709    Ok((
710        s,
711        AttributeValuedForObjectType::Signal(message_id, signal_name, value),
712    ))
713}
714
715fn env_variable_attribute_value(s: &str) -> IResult<&str, AttributeValuedForObjectType> {
716    let (s, _) = tag("EV_").parse(s)?;
717    let (s, _) = ms1(s)?;
718    let (s, env_var_name) = c_ident(s)?;
719    let (s, _) = ms1(s)?;
720    let (s, value) = attribute_value(s)?;
721    Ok((
722        s,
723        AttributeValuedForObjectType::EnvVariable(env_var_name, value),
724    ))
725}
726
727fn raw_attribute_value(s: &str) -> IResult<&str, AttributeValuedForObjectType> {
728    map(attribute_value, AttributeValuedForObjectType::Raw).parse(s)
729}
730
731fn attribute_value_for_object(s: &str) -> IResult<&str, AttributeValueForObject> {
732    let (s, _) = multispace0(s)?;
733    let (s, _) = tag("BA_").parse(s)?;
734    let (s, _) = ms1(s)?;
735    let (s, attribute_name) = char_string(s)?;
736    let (s, _) = ms1(s)?;
737    let (s, attribute_value) = alt((
738        network_node_attribute_value,
739        message_definition_attribute_value,
740        signal_attribute_value,
741        env_variable_attribute_value,
742        raw_attribute_value,
743    ))
744    .parse(s)?;
745    let (s, _) = semi_colon(s)?;
746    let (s, _) = line_ending(s)?;
747    Ok((
748        s,
749        AttributeValueForObject {
750            name: attribute_name.to_string(),
751            value: attribute_value,
752        },
753    ))
754}
755
756// TODO add properties
757fn attribute_definition_node(s: &str) -> IResult<&str, AttributeDefinition> {
758    let (s, _) = tag("BU_").parse(s)?;
759    let (s, _) = ms1(s)?;
760    let (s, node) = take_till(is_semi_colon).parse(s)?;
761    Ok((s, AttributeDefinition::Node(node.to_string())))
762}
763
764// TODO add properties
765fn attribute_definition_signal(s: &str) -> IResult<&str, AttributeDefinition> {
766    let (s, _) = tag("SG_").parse(s)?;
767    let (s, _) = ms1(s)?;
768    let (s, signal) = take_till(is_semi_colon).parse(s)?;
769    Ok((s, AttributeDefinition::Signal(signal.to_string())))
770}
771
772// TODO add properties
773fn attribute_definition_environment_variable(s: &str) -> IResult<&str, AttributeDefinition> {
774    let (s, _) = tag("EV_").parse(s)?;
775    let (s, _) = ms1(s)?;
776    let (s, env_var) = take_till(is_semi_colon).parse(s)?;
777    Ok((
778        s,
779        AttributeDefinition::EnvironmentVariable(env_var.to_string()),
780    ))
781}
782
783// TODO add properties
784fn attribute_definition_message(s: &str) -> IResult<&str, AttributeDefinition> {
785    let (s, _) = tag("BO_").parse(s)?;
786    let (s, _) = ms1(s)?;
787    let (s, message) = take_till(is_semi_colon).parse(s)?;
788    Ok((s, AttributeDefinition::Message(message.to_string())))
789}
790
791// TODO add properties
792fn attribute_definition_plain(s: &str) -> IResult<&str, AttributeDefinition> {
793    let (s, plain) = take_till(is_semi_colon).parse(s)?;
794    Ok((s, AttributeDefinition::Plain(plain.to_string())))
795}
796
797fn attribute_definition(s: &str) -> IResult<&str, AttributeDefinition> {
798    let (s, _) = multispace0(s)?;
799    let (s, _) = tag("BA_DEF_").parse(s)?;
800    let (s, _) = ms1(s)?;
801    let (s, def) = alt((
802        attribute_definition_node,
803        attribute_definition_signal,
804        attribute_definition_environment_variable,
805        attribute_definition_message,
806        attribute_definition_plain,
807    ))
808    .parse(s)?;
809
810    let (s, _) = semi_colon(s)?;
811    let (s, _) = line_ending(s)?;
812    Ok((s, def))
813}
814
815fn symbol(s: &str) -> IResult<&str, Symbol> {
816    let (s, _) = space1(s)?;
817    let (s, symbol) = c_ident(s)?;
818    let (s, _) = line_ending(s)?;
819    Ok((s, Symbol(symbol)))
820}
821
822fn new_symbols(s: &str) -> IResult<&str, Vec<Symbol>> {
823    let (s, _) = multispace0(s)?;
824    let (s, _) = tag("NS_ :").parse(s)?;
825    let (s, _) = space0(s)?;
826    let (s, _) = line_ending(s)?;
827    let (s, symbols) = many0(symbol).parse(s)?;
828    Ok((s, symbols))
829}
830
831/// Network node
832fn node(s: &str) -> IResult<&str, Node> {
833    let (s, _) = multispace0(s)?;
834    let (s, _) = tag("BU_:").parse(s)?;
835    let (s, li) = opt(preceded(ms1, separated_list0(ms1, c_ident))).parse(s)?;
836    let (s, _) = space0(s)?;
837    let (s, _) = line_ending(s)?;
838    Ok((s, Node(li.unwrap_or_default())))
839}
840
841fn signal_type_ref(s: &str) -> IResult<&str, SignalTypeRef> {
842    let (s, _) = multispace0(s)?;
843    let (s, _) = tag("SGTYPE_").parse(s)?;
844    let (s, _) = ms1(s)?;
845    let (s, message_id) = message_id(s)?;
846    let (s, _) = ms1(s)?;
847    let (s, signal_name) = c_ident(s)?;
848    let (s, _) = ms1(s)?;
849    let (s, _) = colon(s)?;
850    let (s, _) = ms1(s)?;
851    let (s, signal_type_name) = c_ident(s)?;
852    let (s, _) = semi_colon(s)?;
853    let (s, _) = line_ending(s)?;
854    Ok((
855        s,
856        SignalTypeRef {
857            message_id,
858            signal_name,
859            signal_type_name,
860        },
861    ))
862}
863
864fn value_table(s: &str) -> IResult<&str, ValueTable> {
865    let (s, _) = multispace0(s)?;
866    let (s, _) = tag("VAL_TABLE_").parse(s)?;
867    let (s, _) = ms1(s)?;
868    let (s, value_table_name) = c_ident(s)?;
869    let (s, value_descriptions) =
870        many_till(preceded(ms0, value_description), preceded(ms0, semi_colon)).parse(s)?;
871    let (s, _) = line_ending(s)?;
872    Ok((
873        s,
874        ValueTable {
875            name: value_table_name,
876            descriptions: value_descriptions.0,
877        },
878    ))
879}
880
881fn extended_multiplex_mapping(s: &str) -> IResult<&str, ExtendedMultiplexMapping> {
882    let (s, _) = ms0(s)?;
883    let (s, min_value) = complete::u64(s)?;
884    let (s, _) = char('-').parse(s)?;
885    let (s, max_value) = complete::u64(s)?;
886    Ok((
887        s,
888        ExtendedMultiplexMapping {
889            min_value,
890            max_value,
891        },
892    ))
893}
894
895fn extended_multiplex(s: &str) -> IResult<&str, ExtendedMultiplex> {
896    let (s, _) = multispace0(s)?;
897    let (s, _) = tag("SG_MUL_VAL_").parse(s)?;
898    let (s, _) = ms1(s)?;
899    let (s, message_id) = message_id(s)?;
900    let (s, _) = ms1(s)?;
901    let (s, signal_name) = c_ident(s)?;
902    let (s, _) = ms1(s)?;
903    let (s, multiplexor_signal_name) = c_ident(s)?;
904    let (s, _) = ms1(s)?;
905    let (s, mappings) = separated_list0(tag(","), extended_multiplex_mapping).parse(s)?;
906    let (s, _) = semi_colon(s)?;
907    let (s, _) = line_ending(s)?;
908    Ok((
909        s,
910        ExtendedMultiplex {
911            message_id,
912            signal_name,
913            multiplexor_signal_name,
914            mappings,
915        },
916    ))
917}
918
919fn signed_or_unsigned_integer(s: &str) -> IResult<&str, SignalExtendedValueType> {
920    value(SignalExtendedValueType::SignedOrUnsignedInteger, tag("0")).parse(s)
921}
922fn ieee_float_32bit(s: &str) -> IResult<&str, SignalExtendedValueType> {
923    value(SignalExtendedValueType::IEEEfloat32Bit, tag("1")).parse(s)
924}
925fn ieee_double_64bit(s: &str) -> IResult<&str, SignalExtendedValueType> {
926    value(SignalExtendedValueType::IEEEdouble64bit, tag("2")).parse(s)
927}
928
929fn signal_extended_value_type(s: &str) -> IResult<&str, SignalExtendedValueType> {
930    alt((
931        signed_or_unsigned_integer,
932        ieee_float_32bit,
933        ieee_double_64bit,
934    ))
935    .parse(s)
936}
937
938fn signal_extended_value_type_list(s: &str) -> IResult<&str, SignalExtendedValueTypeList> {
939    let (s, _) = multispace0(s)?;
940    let (s, _) = tag("SIG_VALTYPE_").parse(s)?;
941    let (s, _) = ms1(s)?;
942    let (s, message_id) = message_id(s)?;
943    let (s, _) = ms1(s)?;
944    let (s, signal_name) = c_ident(s)?;
945    let (s, _) = ms1(s)?;
946    let (s, _) = opt(colon).parse(s)?;
947    let (s, _) = ms1(s)?;
948    let (s, signal_extended_value_type) = signal_extended_value_type(s)?;
949    let (s, _) = semi_colon(s)?;
950    let (s, _) = line_ending(s)?;
951    Ok((
952        s,
953        SignalExtendedValueTypeList {
954            message_id,
955            signal_name,
956            signal_extended_value_type,
957        },
958    ))
959}
960
961fn transmitter_vector_xxx(s: &str) -> IResult<&str, Transmitter> {
962    value(Transmitter::VectorXXX, tag("Vector__XXX")).parse(s)
963}
964
965fn transmitter_node_name(s: &str) -> IResult<&str, Transmitter> {
966    map(c_ident, Transmitter::NodeName).parse(s)
967}
968
969fn transmitter(s: &str) -> IResult<&str, Transmitter> {
970    alt((transmitter_vector_xxx, transmitter_node_name)).parse(s)
971}
972
973fn message_transmitters(s: &str) -> IResult<&str, Vec<Transmitter>> {
974    separated_list0(comma, transmitter).parse(s)
975}
976
977fn message_transmitter(s: &str) -> IResult<&str, MessageTransmitter> {
978    let (s, _) = multispace0(s)?;
979    let (s, _) = tag("BO_TX_BU_").parse(s)?;
980    let (s, _) = ms1(s)?;
981    let (s, message_id) = message_id(s)?;
982    let (s, _) = ms1(s)?;
983    let (s, _) = colon(s)?;
984    let (s, _) = opt(ms1).parse(s)?;
985    let (s, transmitter) = message_transmitters(s)?;
986    let (s, _) = semi_colon(s)?;
987    let (s, _) = line_ending(s)?;
988    Ok((
989        s,
990        MessageTransmitter {
991            message_id,
992            transmitter,
993        },
994    ))
995}
996
997fn signal_groups(s: &str) -> IResult<&str, SignalGroups> {
998    let (s, _) = multispace0(s)?;
999    let (s, _) = tag("SIG_GROUP_").parse(s)?;
1000    let (s, _) = ms1(s)?;
1001    let (s, message_id) = message_id(s)?;
1002    let (s, _) = ms1(s)?;
1003    let (s, signal_group_name) = c_ident(s)?;
1004    let (s, _) = ms1(s)?;
1005    let (s, repetitions) = complete::u64(s)?;
1006    let (s, _) = ms1(s)?;
1007    let (s, _) = colon(s)?;
1008    let (s, _) = ms1(s)?;
1009    let (s, signal_names) = separated_list0(ms1, c_ident).parse(s)?;
1010    let (s, _) = semi_colon(s)?;
1011    let (s, _) = line_ending(s)?;
1012    Ok((
1013        s,
1014        SignalGroups {
1015            message_id,
1016            name: signal_group_name,
1017            repetitions,
1018            signal_names,
1019        },
1020    ))
1021}
1022
1023pub fn dbc(s: &str) -> IResult<&str, Dbc> {
1024    let (
1025        s,
1026        (
1027            version,
1028            new_symbols,
1029            bit_timing,
1030            nodes,
1031            value_tables,
1032            messages,
1033            message_transmitters,
1034            environment_variables,
1035            environment_variable_data,
1036            signal_types,
1037            comments,
1038            attribute_definitions,
1039            attribute_defaults,
1040            attribute_values,
1041            value_descriptions,
1042            signal_type_refs,
1043            signal_groups,
1044            signal_extended_value_type_list,
1045            extended_multiplex,
1046        ),
1047    ) = permutation((
1048        version,
1049        new_symbols,
1050        opt(bit_timing),
1051        many0(node),
1052        many0(value_table),
1053        many0(message),
1054        many0(message_transmitter),
1055        many0(environment_variable),
1056        many0(environment_variable_data),
1057        many0(signal_type),
1058        many0(comment),
1059        many0(attribute_definition),
1060        many0(attribute_default),
1061        many0(attribute_value_for_object),
1062        many0(value_descriptions),
1063        many0(signal_type_ref),
1064        many0(signal_groups),
1065        many0(signal_extended_value_type_list),
1066        many0(extended_multiplex),
1067    ))
1068    .parse(s)?;
1069    let (s, _) = multispace0(s)?;
1070    Ok((
1071        s,
1072        Dbc {
1073            version,
1074            new_symbols,
1075            bit_timing,
1076            nodes,
1077            value_tables,
1078            messages,
1079            message_transmitters,
1080            environment_variables,
1081            environment_variable_data,
1082            signal_types,
1083            comments,
1084            attribute_definitions,
1085            attribute_defaults,
1086            attribute_values,
1087            value_descriptions,
1088            signal_type_refs,
1089            signal_groups,
1090            signal_extended_value_type_list,
1091            extended_multiplex,
1092        },
1093    ))
1094}
1095
1096#[cfg(test)]
1097mod tests {
1098    use super::*;
1099
1100    #[test]
1101    fn c_ident_test() {
1102        let def1 = "EALL_DUSasb18 ";
1103        let (_, cid1) = c_ident(def1).unwrap();
1104        assert_eq!("EALL_DUSasb18", cid1);
1105
1106        let def2 = "_EALL_DUSasb18 ";
1107        let (_, cid2) = c_ident(def2).unwrap();
1108        assert_eq!("_EALL_DUSasb18", cid2);
1109
1110        // identifiers must not start with digits
1111        let def3 = "3EALL_DUSasb18 ";
1112        let cid3_result = c_ident(def3);
1113        assert!(cid3_result.is_err());
1114    }
1115
1116    #[test]
1117    fn c_ident_vec_test() {
1118        let cid = "FZHL_DUSasb18 ";
1119        let (_, cid1) = c_ident_vec(cid).unwrap();
1120
1121        assert_eq!(vec!("FZHL_DUSasb18".to_string()), cid1);
1122
1123        let cid_vec = "FZHL_DUSasb19,xkask_3298 ";
1124        let (_, cid2) = c_ident_vec(cid_vec).unwrap();
1125
1126        assert_eq!(
1127            vec!("FZHL_DUSasb19".to_string(), "xkask_3298".to_string()),
1128            cid2
1129        );
1130    }
1131
1132    #[test]
1133    fn char_string_test() {
1134        let def = "\"ab\x00\x7f\"";
1135        let (_, char_string) = char_string(def).unwrap();
1136        let exp = "ab\x00\x7f";
1137        assert_eq!(exp, char_string);
1138    }
1139
1140    #[test]
1141    fn signal_test() {
1142        let signal_line = "SG_ NAME : 3|2@1- (1,0) [0|0] \"x\" UFA\r\n";
1143        let _signal = signal(signal_line).unwrap();
1144    }
1145
1146    #[test]
1147    fn byte_order_test() {
1148        let (_, big_endian) = byte_order("0").expect("Failed to parse big endian");
1149        assert_eq!(ByteOrder::BigEndian, big_endian);
1150
1151        let (_, little_endian) = byte_order("1").expect("Failed to parse little endian");
1152        assert_eq!(ByteOrder::LittleEndian, little_endian);
1153    }
1154
1155    #[test]
1156    fn multiplexer_indicator_test() {
1157        let (_, multiplexer) =
1158            multiplexer_indicator(" m34920 eol").expect("Failed to parse multiplexer");
1159        assert_eq!(MultiplexIndicator::MultiplexedSignal(34920), multiplexer);
1160
1161        let (_, multiplexor) =
1162            multiplexer_indicator(" M eol").expect("Failed to parse multiplexor");
1163        assert_eq!(MultiplexIndicator::Multiplexor, multiplexor);
1164
1165        let (_, plain) = multiplexer_indicator(" eol").expect("Failed to parse plain");
1166        assert_eq!(MultiplexIndicator::Plain, plain);
1167
1168        let (_, multiplexer) =
1169            multiplexer_indicator(" m8M eol").expect("Failed to parse multiplexer");
1170        assert_eq!(
1171            MultiplexIndicator::MultiplexorAndMultiplexedSignal(8),
1172            multiplexer
1173        );
1174    }
1175
1176    #[test]
1177    fn value_type_test() {
1178        let (_, vt) = value_type("- ").expect("Failed to parse value type");
1179        assert_eq!(ValueType::Signed, vt);
1180
1181        let (_, vt) = value_type("+ ").expect("Failed to parse value type");
1182        assert_eq!(ValueType::Unsigned, vt);
1183    }
1184
1185    #[test]
1186    fn message_definition_test() {
1187        let def = "BO_ 1 MCA_A1: 6 MFA\r\nSG_ ABC_1 : 9|2@1+ (1,0) [0|0] \"x\" XYZ_OUS\r\nSG_ BasL2 : 3|2@0- (1,0) [0|0] \"x\" DFA_FUS\r\n x";
1188        signal("\r\n\r\nSG_ BasL2 : 3|2@0- (1,0) [0|0] \"x\" DFA_FUS\r\n").expect("Failed");
1189        let (_, _message_def) = message(def).expect("Failed to parse message definition");
1190    }
1191
1192    #[test]
1193    fn signal_comment_test() {
1194        let def1 = "CM_ SG_ 193 KLU_R_X \"This is a signal comment test\";\n";
1195        let message_id = MessageId::Standard(193);
1196        let comment1 = Comment::Signal {
1197            message_id,
1198            name: "KLU_R_X".to_string(),
1199            comment: "This is a signal comment test".to_string(),
1200        };
1201        let (_, comment1_def) = comment(def1).expect("Failed to parse signal comment definition");
1202        assert_eq!(comment1, comment1_def);
1203    }
1204
1205    #[test]
1206    fn message_definition_comment_test() {
1207        let def1 = "CM_ BO_ 34544 \"Some Message comment\";\n";
1208        let message_id = MessageId::Standard(34544);
1209        let comment1 = Comment::Message {
1210            id: message_id,
1211            comment: "Some Message comment".to_string(),
1212        };
1213        let (_, comment1_def) =
1214            comment(def1).expect("Failed to parse message definition comment definition");
1215        assert_eq!(comment1, comment1_def);
1216    }
1217
1218    #[test]
1219    fn node_comment_test() {
1220        let def1 = "CM_ BU_ network_node \"Some network node comment\";\n";
1221        let comment1 = Comment::Node {
1222            name: "network_node".to_string(),
1223            comment: "Some network node comment".to_string(),
1224        };
1225        let (_, comment1_def) = comment(def1).expect("Failed to parse node comment definition");
1226        assert_eq!(comment1, comment1_def);
1227    }
1228
1229    #[test]
1230    fn env_var_comment_test() {
1231        let def1 = "CM_ EV_ ENVXYZ \"Some env var name comment\";\n";
1232        let comment1 = Comment::EnvVar {
1233            name: "ENVXYZ".to_string(),
1234            comment: "Some env var name comment".to_string(),
1235        };
1236        let (_, comment1_def) = comment(def1).expect("Failed to parse env var comment definition");
1237        assert_eq!(comment1, comment1_def);
1238    }
1239
1240    #[test]
1241    fn signal_comment_with_escaped_characters_test() {
1242        let def1 = "CM_ SG_ 2147548912 FooBar \"Foo\\\\ \\n \\\"Bar\\\"\";\n";
1243        let message_id = MessageId::Extended(65264);
1244        let comment1 = Comment::Signal {
1245            message_id,
1246            name: "FooBar".to_string(),
1247            comment: "Foo\\\\ \\n \\\"Bar\\\"".to_string(),
1248        };
1249        let (_, comment1_def) = comment(def1).expect("Failed to parse signal comment definition");
1250        assert_eq!(comment1, comment1_def);
1251    }
1252
1253    #[test]
1254    fn empty_signal_comment_test() {
1255        let def1 = "CM_ SG_ 2147548912 FooBar \"\";\n";
1256        let message_id = MessageId::Extended(65264);
1257        let comment1 = Comment::Signal {
1258            message_id,
1259            name: "FooBar".to_string(),
1260            comment: String::new(),
1261        };
1262        let (_, comment1_def) = comment(def1).expect("Failed to parse signal comment definition");
1263        assert_eq!(comment1, comment1_def);
1264    }
1265
1266    #[test]
1267    fn value_description_for_signal_test() {
1268        let def1 = "VAL_ 837 UF_HZ_OI 255 \"NOP\";\n";
1269        let message_id = MessageId::Standard(837);
1270        let signal_name = "UF_HZ_OI".to_string();
1271        let val_descriptions = vec![ValDescription {
1272            id: 255.0,
1273            description: "NOP".to_string(),
1274        }];
1275        let value_description_for_signal1 = ValueDescription::Signal {
1276            message_id,
1277            name: signal_name,
1278            value_descriptions: val_descriptions,
1279        };
1280        let (_, value_signal_def) =
1281            value_descriptions(def1).expect("Failed to parse value desc for signal");
1282        assert_eq!(value_description_for_signal1, value_signal_def);
1283    }
1284
1285    #[test]
1286    fn value_description_for_env_var_test() {
1287        let def1 = "VAL_ MY_ENV_VAR 255 \"NOP\";\n";
1288        let env_var_name = "MY_ENV_VAR".to_string();
1289        let val_descriptions = vec![ValDescription {
1290            id: 255.0,
1291            description: "NOP".to_string(),
1292        }];
1293        let value_env_var1 = ValueDescription::EnvironmentVariable {
1294            name: env_var_name,
1295            value_descriptions: val_descriptions,
1296        };
1297        let (_, value_env_var) =
1298            value_descriptions(def1).expect("Failed to parse value desc for env var");
1299        assert_eq!(value_env_var1, value_env_var);
1300    }
1301
1302    #[test]
1303    fn environment_variable_test() {
1304        let def1 = "EV_ IUV: 0 [-22|20] \"mm\" 3 7 DUMMY_NODE_VECTOR0 VECTOR_XXX;\n";
1305        let env_var1 = EnvironmentVariable {
1306            name: "IUV".to_string(),
1307            typ: EnvType::Float,
1308            min: -22,
1309            max: 20,
1310            unit: "mm".to_string(),
1311            initial_value: 3.0,
1312            ev_id: 7,
1313            access_type: AccessType::DummyNodeVector0,
1314            access_nodes: vec![AccessNode::VectorXXX],
1315        };
1316        let (_, env_var) =
1317            environment_variable(def1).expect("Failed to parse environment variable");
1318        assert_eq!(env_var1, env_var);
1319    }
1320
1321    #[test]
1322    fn network_node_attribute_value_test() {
1323        let def = "BA_ \"AttrName\" BU_ NodeName 12;\n";
1324        let attribute_value = AttributeValuedForObjectType::NetworkNode(
1325            "NodeName".to_string(),
1326            AttributeValue::Double(12.0),
1327        );
1328        let attr_val_exp = AttributeValueForObject {
1329            name: "AttrName".to_string(),
1330            value: attribute_value,
1331        };
1332        let (_, attr_val) = attribute_value_for_object(def).unwrap();
1333        assert_eq!(attr_val_exp, attr_val);
1334    }
1335
1336    #[test]
1337    fn message_definition_attribute_value_test() {
1338        let def = "BA_ \"AttrName\" BO_ 298 13;\n";
1339        let attribute_value = AttributeValuedForObjectType::MessageDefinition(
1340            MessageId::Standard(298),
1341            Some(AttributeValue::Double(13.0)),
1342        );
1343        let attr_val_exp = AttributeValueForObject {
1344            name: "AttrName".to_string(),
1345            value: attribute_value,
1346        };
1347        let (_, attr_val) = attribute_value_for_object(def).unwrap();
1348        assert_eq!(attr_val_exp, attr_val);
1349    }
1350
1351    #[test]
1352    fn signal_attribute_value_test() {
1353        let def = "BA_ \"AttrName\" SG_ 198 SGName 13;\n";
1354        let attribute_value = AttributeValuedForObjectType::Signal(
1355            MessageId::Standard(198),
1356            "SGName".to_string(),
1357            AttributeValue::Double(13.0),
1358        );
1359        let attr_val_exp = AttributeValueForObject {
1360            name: "AttrName".to_string(),
1361            value: attribute_value,
1362        };
1363        let (_, attr_val) = attribute_value_for_object(def).unwrap();
1364        assert_eq!(attr_val_exp, attr_val);
1365    }
1366
1367    #[test]
1368    fn env_var_attribute_value_test() {
1369        let def = "BA_ \"AttrName\" EV_ EvName \"CharStr\";\n";
1370        let attribute_value = AttributeValuedForObjectType::EnvVariable(
1371            "EvName".to_string(),
1372            AttributeValue::String("CharStr".to_string()),
1373        );
1374        let attr_val_exp = AttributeValueForObject {
1375            name: "AttrName".to_string(),
1376            value: attribute_value,
1377        };
1378        let (_, attr_val) = attribute_value_for_object(def).unwrap();
1379        assert_eq!(attr_val_exp, attr_val);
1380    }
1381
1382    #[test]
1383    fn raw_attribute_value_test() {
1384        let def = "BA_ \"AttrName\" \"RAW\";\n";
1385        let attribute_value =
1386            AttributeValuedForObjectType::Raw(AttributeValue::String("RAW".to_string()));
1387        let attr_val_exp = AttributeValueForObject {
1388            name: "AttrName".to_string(),
1389            value: attribute_value,
1390        };
1391        let (_, attr_val) = attribute_value_for_object(def).unwrap();
1392        assert_eq!(attr_val_exp, attr_val);
1393    }
1394
1395    #[test]
1396    fn new_symbols_test() {
1397        let def = "NS_ :
1398                NS_DESC_
1399                CM_
1400                BA_DEF_
1401
1402            ";
1403        let symbols_exp = vec![
1404            Symbol("NS_DESC_".to_string()),
1405            Symbol("CM_".to_string()),
1406            Symbol("BA_DEF_".to_string()),
1407        ];
1408        let (_, symbols) = new_symbols(def).unwrap();
1409        assert_eq!(symbols_exp, symbols);
1410    }
1411
1412    #[test]
1413    fn network_node_test() {
1414        let def = "BU_: ZU XYZ ABC OIU\n";
1415        let nodes = vec![
1416            "ZU".to_string(),
1417            "XYZ".to_string(),
1418            "ABC".to_string(),
1419            "OIU".to_string(),
1420        ];
1421        let (_, node) = node(def).unwrap();
1422        let node_exp = Node(nodes);
1423        assert_eq!(node_exp, node);
1424    }
1425
1426    #[test]
1427    fn empty_network_node_test() {
1428        let def = "BU_: \n";
1429        let nodes = vec![];
1430        let (_, node) = node(def).unwrap();
1431        let node_exp = Node(nodes);
1432        assert_eq!(node_exp, node);
1433    }
1434
1435    #[test]
1436    fn envvar_data_test() {
1437        let def = "ENVVAR_DATA_ SomeEnvVarData: 399;\n";
1438        let (_, envvar_data) = environment_variable_data(def).unwrap();
1439        let envvar_data_exp = EnvironmentVariableData {
1440            env_var_name: "SomeEnvVarData".to_string(),
1441            data_size: 399,
1442        };
1443        assert_eq!(envvar_data_exp, envvar_data);
1444    }
1445
1446    #[test]
1447    fn signal_type_test() {
1448        let def = "SGTYPE_ signal_type_name: 1024@1+ (5,2) [1|3] \"unit\" 2.0 val_table;\n";
1449
1450        let exp = SignalType {
1451            name: "signal_type_name".to_string(),
1452            signal_size: 1024,
1453            byte_order: ByteOrder::LittleEndian,
1454            value_type: ValueType::Unsigned,
1455            factor: 5.0,
1456            offset: 2.0,
1457            min: 1.0,
1458            max: 3.0,
1459            unit: "unit".to_string(),
1460            default_value: 2.0,
1461            value_table: "val_table".to_string(),
1462        };
1463
1464        let (_, signal_type) = signal_type(def).unwrap();
1465        assert_eq!(exp, signal_type);
1466    }
1467
1468    #[test]
1469    fn signal_groups_test() {
1470        let def = "SIG_GROUP_ 23 X_3290 1 : A_b XY_Z;\n";
1471
1472        let exp = SignalGroups {
1473            message_id: MessageId::Standard(23),
1474            name: "X_3290".to_string(),
1475            repetitions: 1,
1476            signal_names: vec!["A_b".to_string(), "XY_Z".to_string()],
1477        };
1478
1479        let (_, signal_groups) = signal_groups(def).unwrap();
1480        assert_eq!(exp, signal_groups);
1481    }
1482
1483    #[test]
1484    fn attribute_default_test() {
1485        let def = "BA_DEF_DEF_  \"ZUV\" \"OAL\";\n";
1486        let (_, attr_default) = attribute_default(def).unwrap();
1487        let attr_default_exp = AttributeDefault {
1488            name: "ZUV".to_string(),
1489            value: AttributeValue::String("OAL".to_string()),
1490        };
1491        assert_eq!(attr_default_exp, attr_default);
1492    }
1493
1494    #[test]
1495    fn attribute_value_f64_test() {
1496        let def = "80.0";
1497        let (_, val) = attribute_value(def).unwrap();
1498        assert_eq!(AttributeValue::Double(80.0), val);
1499    }
1500
1501    #[test]
1502    fn attribute_definition_test() {
1503        let def_bo = "BA_DEF_ BO_ \"BaDef1BO\" INT 0 1000000;\n";
1504        let (_, bo_def) = attribute_definition(def_bo).unwrap();
1505        let bo_def_exp = AttributeDefinition::Message("\"BaDef1BO\" INT 0 1000000".to_string());
1506        assert_eq!(bo_def_exp, bo_def);
1507
1508        let def_bu = "BA_DEF_ BU_ \"BuDef1BO\" INT 0 1000000;\n";
1509        let (_, bu_def) = attribute_definition(def_bu).unwrap();
1510        let bu_def_exp = AttributeDefinition::Node("\"BuDef1BO\" INT 0 1000000".to_string());
1511        assert_eq!(bu_def_exp, bu_def);
1512
1513        let def_signal = "BA_DEF_ SG_ \"SgDef1BO\" INT 0 1000000;\n";
1514        let (_, signal_def) = attribute_definition(def_signal).unwrap();
1515        let signal_def_exp = AttributeDefinition::Signal("\"SgDef1BO\" INT 0 1000000".to_string());
1516        assert_eq!(signal_def_exp, signal_def);
1517
1518        let def_env_var = "BA_DEF_ EV_ \"EvDef1BO\" INT 0 1000000;\n";
1519        let (_, env_var_def) = attribute_definition(def_env_var).unwrap();
1520        let env_var_def_exp =
1521            AttributeDefinition::EnvironmentVariable("\"EvDef1BO\" INT 0 1000000".to_string());
1522        assert_eq!(env_var_def_exp, env_var_def);
1523    }
1524
1525    #[test]
1526    fn version_test() {
1527        let def = "VERSION \"HNPBNNNYNNNNNNNNNNNNNNNNNNNNNNNNYNYYYYYYYY>4>%%%/4>'%**4YYY///\"\n";
1528        let version_exp =
1529            Version("HNPBNNNYNNNNNNNNNNNNNNNNNNNNNNNNYNYYYYYYYY>4>%%%/4>'%**4YYY///".to_string());
1530        let (_, version) = version(def).unwrap();
1531        assert_eq!(version_exp, version);
1532    }
1533
1534    #[test]
1535    fn message_transmitters_test() {
1536        let def = "BO_TX_BU_ 12345 : XZY,ABC;\n";
1537        let exp = MessageTransmitter {
1538            message_id: MessageId::Standard(12345),
1539            transmitter: vec![
1540                Transmitter::NodeName("XZY".to_string()),
1541                Transmitter::NodeName("ABC".to_string()),
1542            ],
1543        };
1544        let (_, transmitter) = message_transmitter(def).unwrap();
1545        assert_eq!(exp, transmitter);
1546
1547        // Same as above, but without space before the colon
1548        let def = "BO_TX_BU_ 12345 :XZY,ABC;\n";
1549        let (_, transmitter) = message_transmitter(def).unwrap();
1550        assert_eq!(exp, transmitter);
1551    }
1552
1553    #[test]
1554    fn value_description_test() {
1555        let def = "2 \"ABC\"\n";
1556        let exp = ValDescription {
1557            id: 2f64,
1558            description: "ABC".to_string(),
1559        };
1560        let (_, val_desc) = value_description(def).unwrap();
1561        assert_eq!(exp, val_desc);
1562    }
1563
1564    #[test]
1565    fn val_table_test() {
1566        let def = "VAL_TABLE_ Tst 2 \"ABC\" 1 \"Test A\" ;\n";
1567        let exp = ValueTable {
1568            name: "Tst".to_string(),
1569            descriptions: vec![
1570                ValDescription {
1571                    id: 2f64,
1572                    description: "ABC".to_string(),
1573                },
1574                ValDescription {
1575                    id: 1f64,
1576                    description: "Test A".to_string(),
1577                },
1578            ],
1579        };
1580        let (_, val_table) = value_table(def).unwrap();
1581        assert_eq!(exp, val_table);
1582    }
1583
1584    #[test]
1585    fn val_table_no_space_preceding_comma_test() {
1586        let def = "VAL_TABLE_ Tst 2 \"ABC\";\n";
1587        let exp = ValueTable {
1588            name: "Tst".to_string(),
1589            descriptions: vec![ValDescription {
1590                id: 2f64,
1591                description: "ABC".to_string(),
1592            }],
1593        };
1594        let (_, val_table) = value_table(def).unwrap();
1595        assert_eq!(exp, val_table);
1596    }
1597
1598    #[test]
1599    fn extended_multiplex_test() {
1600        // simple mapping
1601        let def = "SG_MUL_VAL_ 2147483650 muxed_A_1 MUX_A 1-1;\n";
1602        let exp = ExtendedMultiplex {
1603            message_id: MessageId::Extended(2),
1604            signal_name: "muxed_A_1".to_string(),
1605            multiplexor_signal_name: "MUX_A".to_string(),
1606            mappings: vec![ExtendedMultiplexMapping {
1607                min_value: 1,
1608                max_value: 1,
1609            }],
1610        };
1611        let (_, ext_multiplex) = extended_multiplex(def).unwrap();
1612        assert_eq!(exp, ext_multiplex);
1613
1614        // range mapping
1615        let def = "SG_MUL_VAL_ 2147483650 muxed_A_1 MUX_A 1568-2568;\n";
1616        let exp = ExtendedMultiplex {
1617            message_id: MessageId::Extended(2),
1618            signal_name: "muxed_A_1".to_string(),
1619            multiplexor_signal_name: "MUX_A".to_string(),
1620            mappings: vec![ExtendedMultiplexMapping {
1621                min_value: 1568,
1622                max_value: 2568,
1623            }],
1624        };
1625        let (_, ext_multiplex) = extended_multiplex(def).unwrap();
1626        assert_eq!(exp, ext_multiplex);
1627
1628        // multiple mappings
1629        let def = "SG_MUL_VAL_ 2147483650 muxed_B_5 MUX_B 5-5, 16-24;\n";
1630        let exp = ExtendedMultiplex {
1631            message_id: MessageId::Extended(2),
1632            signal_name: "muxed_B_5".to_string(),
1633            multiplexor_signal_name: "MUX_B".to_string(),
1634            mappings: vec![
1635                ExtendedMultiplexMapping {
1636                    min_value: 5,
1637                    max_value: 5,
1638                },
1639                ExtendedMultiplexMapping {
1640                    min_value: 16,
1641                    max_value: 24,
1642                },
1643            ],
1644        };
1645        let (_, ext_multiplex) = extended_multiplex(def).unwrap();
1646        assert_eq!(exp, ext_multiplex);
1647    }
1648
1649    #[test]
1650    fn sig_val_type_test() {
1651        let def = "SIG_VALTYPE_ 2000 Signal_8 : 1;\n";
1652        let exp = SignalExtendedValueTypeList {
1653            message_id: MessageId::Standard(2000),
1654            signal_name: "Signal_8".to_string(),
1655            signal_extended_value_type: SignalExtendedValueType::IEEEfloat32Bit,
1656        };
1657
1658        let (_, extended_value_type_list) = signal_extended_value_type_list(def).unwrap();
1659        assert_eq!(extended_value_type_list, exp);
1660    }
1661
1662    #[test]
1663    fn standard_message_id_test() {
1664        let (_, extended_message_id) = message_id("2").unwrap();
1665        assert_eq!(extended_message_id, MessageId::Standard(2));
1666    }
1667
1668    #[test]
1669    fn extended_low_message_id_test() {
1670        let s = (2u32 | 1 << 31).to_string();
1671        let (_, extended_message_id) = message_id(&s).unwrap();
1672        assert_eq!(extended_message_id, MessageId::Extended(2));
1673    }
1674
1675    #[test]
1676    fn extended_message_id_test() {
1677        let s = (0x1FFF_FFFF_u32 | 1 << 31).to_string();
1678        let (_, extended_message_id) = message_id(&s).unwrap();
1679        assert_eq!(extended_message_id, MessageId::Extended(0x1FFF_FFFF));
1680    }
1681
1682    #[test]
1683    fn extended_message_id_test_max_29bit() {
1684        let s = u32::MAX.to_string();
1685        let (_, extended_message_id) = message_id(&s).unwrap();
1686        assert_eq!(extended_message_id, MessageId::Extended(0x1FFF_FFFF));
1687    }
1688}
can_dbc/parser.rs

can_dbc/
parser.rs
