handle case of signal events with bitwidths shorter than nominal signal length

Author: ThePerfectComputer

src/vcd/parse.rs

@@ -273,12 +273,12 @@ fn parse_events<'a>(
                         // Also account for the error case of a bitwidth of `None`
                         match num_bits {
                             Some(ref num_bits) => {
-                                if *num_bits > observed_num_bits {
+                                if observed_num_bits > *num_bits {
                                     let (f, l) = (file!(), line!());
                                     let msg = format!("\
                                         Error near {f}:{l}. The bitwidth for signal {name} \
-                                        of sig_type {sig_type:?} is expected to be `1` not \
-                                        `{num_bits}`. \
+                                        of sig_type {sig_type:?} is expected to be `{num_bits}` not \
+                                        `{observed_num_bits}`. \
                                         This error occurred while parsing the vcd file at \
                                         {cursor:?}");
                                     *signal_error = Some(msg);
@@ -309,7 +309,31 @@ fn parse_events<'a>(
                         }
                         else {
                             u8_timeline_markers.push(timeline_idx);
+                            
+                            let mut curr_num_bytes = value_u8.len();
                             u8_timeline.append(&mut value_u8);
+
+                            // we may need to zero extend values 
+                            // so that we end up storing all values
+                            // of a particular signal in a consistent
+                            // amount of bytes
+                            let num_bits = num_bits.unwrap();
+                            let bytes_required = (num_bits / 8) +
+                                if (num_bits % 8) > 0 {1} else {0};
+
+                            while curr_num_bytes < bytes_required {
+                                // useful for debugging
+                                // let err = format!("Error at {cursor:?}.\
+                                // num_bits = {num_bits}, \
+                                // observed_bits = {observed_num_bits}, \
+                                // curr_num_bytes = {curr_num_bytes}, \
+                                // bytes_required = {bytes_required} \
+                                // for signal {name}");
+                                // Err(err)?;
+
+                                u8_timeline.push(0u8);
+                                curr_num_bytes += 1;
+                            }
                             Ok(())
                         }
                     }
@@ -402,9 +426,7 @@ fn parse_events<'a>(
                 }?;
             }
 
-            // other one bit cases
-            "x" | "X" | "z" | "Z" | "u" | "U" => {
-                let val = word.to_string();
+            "1" => {
                 // lokup signal idx
                 let hash = &word[1..];
                 let (f, l )= (file!(), line!());
@@ -431,8 +453,7 @@ fn parse_events<'a>(
                 let signal = vcd.all_signals.get_mut(signal_idx).unwrap();
                 match signal {
                     Signal::Data {name, sig_type, ref mut signal_error, num_bits, 
-                    self_idx, u8_timeline, u8_timeline_markers, string_timeline,
-                    string_timeline_markers, ..} => {
+                    self_idx, u8_timeline, u8_timeline_markers, scope_parent, ..} => {
 
                         // if this is a bad signal, go ahead and skip it
                         if signal_error.is_some() {continue;}
@@ -469,8 +490,8 @@ fn parse_events<'a>(
                             |e| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?;
                         let timeline_idx = TimelineIdx(timeline_idx);
 
-                        string_timeline_markers.push(timeline_idx);
-                        string_timeline.push(val);
+                        u8_timeline_markers.push(timeline_idx);
+                        u8_timeline.push(1u8);
                         Ok(())
                     }
                     Signal::Alias {..} => {
@@ -482,7 +503,9 @@ fn parse_events<'a>(
                     }
                 }?;
             }
-            "1" => {
+            // other one bit cases
+            "x" | "X" | "z" | "Z" | "u" | "U" => {
+                let val = word.to_string();
                 // lokup signal idx
                 let hash = &word[1..];
                 let (f, l )= (file!(), line!());
@@ -509,7 +532,8 @@ fn parse_events<'a>(
                 let signal = vcd.all_signals.get_mut(signal_idx).unwrap();
                 match signal {
                     Signal::Data {name, sig_type, ref mut signal_error, num_bits, 
-                    self_idx, u8_timeline, u8_timeline_markers, scope_parent, ..} => {
+                    self_idx, u8_timeline, u8_timeline_markers, string_timeline,
+                    string_timeline_markers, ..} => {
 
                         // if this is a bad signal, go ahead and skip it
                         if signal_error.is_some() {continue;}
@@ -546,8 +570,8 @@ fn parse_events<'a>(
                             |e| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?;
                         let timeline_idx = TimelineIdx(timeline_idx);
 
-                        u8_timeline_markers.push(timeline_idx);
-                        u8_timeline.push(1u8);
+                        string_timeline_markers.push(timeline_idx);
+                        string_timeline.push(val);
                         Ok(())
                     }
                     Signal::Alias {..} => {