Compute num_bytes ahead of time; Start removing undeeded signals from match arms

src/vcd/parse/events.rs

@@ -121,6 +121,7 @@ pub(super) fn parse_events<'a>(
                         sig_type,
                         ref mut signal_error,
                         num_bits,
+                        num_bytes,
                         self_idx,
                         nums_encoded_as_fixed_width_le_u8,
                         string_vals,
@@ -190,7 +191,9 @@ pub(super) fn parse_events<'a>(
                             // so that we end up storing all values
                             // of a particular signal in a consistent
                             // amount of bytes
-                            let bytes_required = Signal::bytes_required(num_bits, name)?;
+                            let bytes_required = num_bytes.ok_or_else(|| {
+                                format!("Error near {}:{}. num_bytes empty.", file!(), line!())
+                            })?;
 
                             while curr_num_bytes < bytes_required {
                                 nums_encoded_as_fixed_width_le_u8.push(0u8);
@@ -230,14 +233,13 @@ pub(super) fn parse_events<'a>(
                         sig_type,
                         ref mut signal_error,
                         num_bits,
-                        self_idx,
+                        num_bytes: _,
+                        self_idx: _,
                         nums_encoded_as_fixed_width_le_u8,
-                        string_vals,
+                        string_vals: _,
                         lsb_indxs_of_num_tmstmp_vals_on_tmln,
                         byte_len_of_num_tmstmp_vals_on_tmln,
-                        lsb_indxs_of_string_tmstmp_vals_on_tmln,
+                        ..
-                        byte_len_of_string_tmstmp_vals_on_tmln,
-                        scope_parent,
                     } => {
                         // if this is a bad signal, go ahead and skip it
                         if signal_error.is_some() {
@@ -309,14 +311,13 @@ pub(super) fn parse_events<'a>(
                         sig_type,
                         ref mut signal_error,
                         num_bits,
-                        self_idx,
+                        num_bytes: _,
+                        self_idx: _,
                         nums_encoded_as_fixed_width_le_u8,
-                        string_vals,
+                        string_vals: _,
                         lsb_indxs_of_num_tmstmp_vals_on_tmln,
                         byte_len_of_num_tmstmp_vals_on_tmln,
-                        lsb_indxs_of_string_tmstmp_vals_on_tmln,
+                        ..
-                        byte_len_of_string_tmstmp_vals_on_tmln,
-                        scope_parent,
                     } => {
                         // if this is a bad signal, go ahead and skip it
                         if signal_error.is_some() {
@@ -390,14 +391,14 @@ pub(super) fn parse_events<'a>(
                         sig_type,
                         ref mut signal_error,
                         num_bits,
-                        self_idx,
+                        num_bytes: _,
-                        nums_encoded_as_fixed_width_le_u8,
+                        self_idx: _,
+                        nums_encoded_as_fixed_width_le_u8: _,
                         string_vals,
-                        lsb_indxs_of_num_tmstmp_vals_on_tmln,
+                        lsb_indxs_of_num_tmstmp_vals_on_tmln: _,
-                        byte_len_of_num_tmstmp_vals_on_tmln,
+                        byte_len_of_num_tmstmp_vals_on_tmln: _,
                         lsb_indxs_of_string_tmstmp_vals_on_tmln,
-                        byte_len_of_string_tmstmp_vals_on_tmln,
+                        ..
-                        scope_parent,
                     } => {
                         // if this is a bad signal, go ahead and skip it
                         if signal_error.is_some() {

src/vcd/parse/scopes.rs

@@ -89,6 +89,13 @@ pub(super) fn parse_var<'a>(
     }
     let full_signal_name = full_signal_name.join(" ");
 
+    let num_bytes = if no_bits.is_some() {
+        let bytes_required = Signal::bytes_required(no_bits.unwrap(), &full_signal_name)?;
+        Some(bytes_required)
+    } else {
+        None
+    };
+
     // Is the current variable an alias to a signal already encountered?
     // if so, handle ref_signal_idx accordingly, if not, add signal to hash
     // map
@@ -109,6 +116,7 @@ pub(super) fn parse_var<'a>(
                 sig_type: var_type,
                 signal_error: None,
                 num_bits: no_bits,
+                num_bytes: num_bytes,
                 self_idx: signal_idx,
                 nums_encoded_as_fixed_width_le_u8: vec![],
                 string_vals: vec![],

src/vcd/signal.rs

@@ -36,6 +36,7 @@ pub(super) enum Signal {
         // errors in the following type:
         signal_error: Option<String>,
         num_bits: Option<u16>,
+        num_bytes: Option<u8>,
         // TODO : may be able to remove self_idx
         self_idx: SignalIdx,
         // A signal may take on a new value and hold that value
@@ -79,6 +80,7 @@ pub(super) enum LookupErrors {
     OrderingFailure,
     PointsToAlias,
     NoNumBits,
+    NoNumBytes,
     Other(String),
 }
 
@@ -87,9 +89,7 @@ type TimeStamp = BigUint;
 type SignalValNum = BigUint;
 
 impl Signal {
-    pub(super) fn bytes_required(num_bits: &Option<u16>, name: &String) -> Result<u8, String> {
+    pub(super) fn bytes_required(num_bits: u16, name: &String) -> Result<u8, String> {
-        let num_bits = num_bits
-            .ok_or_else(|| format!("Error near {}:{}. num_bits empty.", file!(), line!()))?;
         let bytes_required = (num_bits / 8) + if (num_bits % 8) > 0 { 1 } else { 0 };
         let bytes_required = u8::try_from(bytes_required).map_err(|_| {
             format!(
@@ -107,33 +107,24 @@ impl Signal {
         tmstmps_encoded_as_u8s: &Vec<u8>,
     ) -> Result<(TimeStamp, SignalValNum), LookupErrors> {
         let (
-            name,
+            num_bytes,
-            num_bits,
             nums_encoded_as_fixed_width_le_u8,
             lsb_indxs_of_num_tmstmp_vals_on_tmln,
             byte_len_of_num_tmstmp_vals_on_tmln,
         ) = match self {
             Signal::Data {
-                name,
+                num_bytes,
-                sig_type,
-                signal_error,
-                num_bits,
-                self_idx,
                 nums_encoded_as_fixed_width_le_u8,
-                string_vals,
                 lsb_indxs_of_num_tmstmp_vals_on_tmln,
                 byte_len_of_num_tmstmp_vals_on_tmln,
-                lsb_indxs_of_string_tmstmp_vals_on_tmln,
+                ..
-                byte_len_of_string_tmstmp_vals_on_tmln,
-                scope_parent,
             } => Ok((
-                name,
+                num_bytes,
-                num_bits,
                 nums_encoded_as_fixed_width_le_u8,
                 lsb_indxs_of_num_tmstmp_vals_on_tmln,
                 byte_len_of_num_tmstmp_vals_on_tmln,
             )),
-            Signal::Alias { name, signal_alias } => Err(LookupErrors::PointsToAlias),
+            Signal::Alias { .. } => Err(LookupErrors::PointsToAlias),
         }?;
 
         // get index
@@ -146,9 +137,8 @@ impl Signal {
         let timestamp = BigUint::from_bytes_le(timestamp);
 
         // get signal value
-        let bytes_per_value =
+        let bytes_per_value = num_bytes.ok_or_else(|| LookupErrors::NoNumBytes)?;
-            Signal::bytes_required(num_bits, name).map_err(|e| LookupErrors::Other(e))?;
+        let bytes_per_value = bytes_per_value as usize;
-        let bytes_per_value = byte_len as usize;
         let start_idx = idx * bytes_per_value;
         let end_idx = (idx + 1) * bytes_per_value;
         let signal_val = &nums_encoded_as_fixed_width_le_u8[start_idx..end_idx];