Run cargo-fmt

src/lib.rs

@@ -5,8 +5,8 @@
 
 mod vcd;
 pub use vcd::parse::parse_vcd;
-pub use vcd::types::{ScopeIdx, SignalIdx, VCD};
-pub use vcd::types::{Metadata, Timescale, Version};
 pub use vcd::signal::{Signal, SignalValue};
+pub use vcd::types::{Metadata, Timescale, Version};
+pub use vcd::types::{ScopeIdx, SignalIdx, VCD};
 
 pub use num::BigUint;

src/vcd.rs

@@ -3,8 +3,8 @@
 // and the YEHOWSHUA license, both of which can be found at
 // the root of the folder containing the sources for this program.
 
-mod reader;
-pub(crate) mod types;
 pub(crate) mod parse;
+mod reader;
 pub(crate) mod signal;
-mod utilities;
+pub(crate) mod types;
+mod utilities;

src/vcd/parse.rs

@@ -4,11 +4,10 @@
 // the root of the folder containing the sources for this program.
 
 mod combinator_atoms;
-mod types;
+mod events;
 mod metadata;
 mod scopes;
-mod events;
-
+mod types;
 
 pub fn parse_vcd(file: impl std::io::Read) -> Result<super::types::VCD, String> {
     let mut word_gen = super::reader::WordReader::new(file);
@@ -26,7 +25,7 @@ pub fn parse_vcd(file: impl std::io::Read) -> Result<super::types::VCD, String>
         all_signals: vec![],
         all_scopes: vec![],
         root_scopes: vec![],
-        largest_timestamp: None
+        largest_timestamp: None,
     };
 
     scopes::parse_scopes(&mut word_gen, &mut vcd, &mut signal_map)?;

src/vcd/parse/events.rs

@@ -3,14 +3,13 @@
 // and the YEHOWSHUA license, both of which can be found at
 // the root of the folder containing the sources for this program.
 
-use std::collections::HashMap;
 use num::BigUint;
+use std::collections::HashMap;
 
-use super::super::utilities::{BinaryParserErrTypes, binary_str_to_vec_u8};
-use super::super::signal::{SignalEnum, LsbIdxOfTmstmpValOnTmln};
-use super::super::reader::{WordReader, Cursor, Line, Word, next_word};
+use super::super::reader::{next_word, Cursor, Line, Word, WordReader};
+use super::super::signal::{LsbIdxOfTmstmpValOnTmln, SignalEnum};
 use super::super::types::{SignalIdx, VCD};
-
+use super::super::utilities::{binary_str_to_vec_u8, BinaryParserErrTypes};
 
 pub(super) fn parse_events<'a, R: std::io::Read>(
     word_reader: &mut WordReader<R>,

src/vcd/parse/metadata.rs

@@ -5,11 +5,11 @@
 use chrono::prelude::{DateTime, Utc};
 use itertools::Itertools;
 
-use super::super::reader::{Cursor, WordReader, next_word};
-use super::super::types::{Timescale, Version, Metadata};
+use super::super::reader::{next_word, Cursor, WordReader};
+use super::super::types::{Metadata, Timescale, Version};
 
-use super::combinator_atoms::{take_until, take_while, digit, tag};
-use super::types::{ParseResult};
+use super::combinator_atoms::{digit, tag, take_until, take_while};
+use super::types::ParseResult;
 
 pub(super) fn parse_date(
     word_and_ctx1: (&str, &Cursor),
@@ -145,7 +145,9 @@ pub(super) fn parse_date(
     ))
 }
 
-pub(super) fn parse_version<R: std::io::Read>(word_reader: &mut WordReader<R>) -> Result<Version, String> {
+pub(super) fn parse_version<R: std::io::Read>(
+    word_reader: &mut WordReader<R>,
+) -> Result<Version, String> {
     let mut version = String::new();
 
     loop {
@@ -220,7 +222,9 @@ pub(super) fn parse_timescale<R: std::io::Read>(
     return Ok(timescale);
 }
 
-pub(super) fn parse_metadata<R: std::io::Read>(word_reader: &mut WordReader<R>) -> Result<Metadata, String> {
+pub(super) fn parse_metadata<R: std::io::Read>(
+    word_reader: &mut WordReader<R>,
+) -> Result<Metadata, String> {
     let mut metadata = Metadata {
         date: None,
         version: None,

src/vcd/parse/scopes.rs

@@ -5,15 +5,14 @@
 
 /// part of the vcd parser that handles parsing the signal tree and
 /// building the resulting signal tree
-
 use std::collections::HashMap;
 
-use super::super::reader::{WordReader, next_word, curr_word};
-use super::super::types::{VCD, Scope, ScopeIdx, SignalIdx};
+use super::super::reader::{curr_word, next_word, WordReader};
 use super::super::signal::{SigType, SignalEnum};
+use super::super::types::{Scope, ScopeIdx, SignalIdx, VCD};
 
-use super::combinator_atoms::{tag, ident};
-use super::types::{ParseResult};
+use super::combinator_atoms::{ident, tag};
+use super::types::ParseResult;
 
 pub(super) fn parse_var<'a, R: std::io::Read>(
     word_reader: &mut WordReader<R>,
@@ -98,7 +97,7 @@ pub(super) fn parse_var<'a, R: std::io::Read>(
         let (word, _) = next_word!(word_reader)?;
         match word {
             "$end" => break,
-            _ => full_signal_name.push(word.to_string())
+            _ => full_signal_name.push(word.to_string()),
         }
     }
     let full_signal_name = full_signal_name.join(" ");
@@ -118,7 +117,11 @@ pub(super) fn parse_var<'a, R: std::io::Read>(
             let signal_idx = SignalIdx(vcd.all_signals.len());
             let signal = SignalEnum::Alias {
                 name: full_signal_name.clone(),
-                path: path.iter().cloned().chain([full_signal_name]).collect::<Vec<String>>(),
+                path: path
+                    .iter()
+                    .cloned()
+                    .chain([full_signal_name])
+                    .collect::<Vec<String>>(),
                 signal_alias: *ref_signal_idx,
             };
             (signal, signal_idx)
@@ -128,7 +131,11 @@ pub(super) fn parse_var<'a, R: std::io::Read>(
             signal_map.insert(signal_alias.to_string(), signal_idx);
             let signal = SignalEnum::Data {
                 name: full_signal_name.clone(),
-                path: path.iter().cloned().chain([full_signal_name]).collect::<Vec<String>>(),
+                path: path
+                    .iter()
+                    .cloned()
+                    .chain([full_signal_name])
+                    .collect::<Vec<String>>(),
                 sig_type: var_type,
                 signal_error: None,
                 num_bits,
@@ -223,7 +230,7 @@ fn parse_scopes_inner<'a, R: std::io::Read>(
     parent_scope_idx: Option<ScopeIdx>,
     vcd: &'a mut VCD,
     signal_map: &mut HashMap<String, SignalIdx>,
-    path: &Vec<String>
+    path: &Vec<String>,
 ) -> Result<(), String> {
     // $scope module reg_mag_i $end
     //        ^^^^^^ - module keyword
@@ -275,8 +282,6 @@ fn parse_scopes_inner<'a, R: std::io::Read>(
     //                         ^^^^ - end keyword
     ident(word_reader, "$end")?;
 
-
-
     loop {
         let (word, cursor) = next_word!(word_reader)?;
         let ParseResult { matched, residual } = tag(word, "$");
@@ -286,7 +291,13 @@ fn parse_scopes_inner<'a, R: std::io::Read>(
                 match residual {
                     "scope" => {
                         // recursive - parse inside of current scope tree
-                        parse_scopes_inner(word_reader, Some(curr_scope_idx), vcd, signal_map, &path)?;
+                        parse_scopes_inner(
+                            word_reader,
+                            Some(curr_scope_idx),
+                            vcd,
+                            signal_map,
+                            &path,
+                        )?;
                     }
                     "var" => {
                         parse_var(word_reader, curr_scope_idx, vcd, signal_map, &path)?;

src/vcd/parse/types.rs

@@ -4,26 +4,24 @@
 // the root of the folder containing the sources for this program.
 #[derive(Debug)]
 pub(super) struct ParseResult<'a> {
-    pub(super) matched : &'a str, 
-    pub(super) residual : &'a str}
+    pub(super) matched: &'a str,
+    pub(super) residual: &'a str,
+}
 
 impl<'a> ParseResult<'a> {
-
-    pub(super) fn assert_match(& self) -> Result<&str, String> {
+    pub(super) fn assert_match(&self) -> Result<&str, String> {
         if self.matched == "" {
-            return Err("no match".to_string())
-        }
-        else {
-            return Ok(self.matched)
+            return Err("no match".to_string());
+        } else {
+            return Ok(self.matched);
         }
     }
 
-    pub(super) fn assert_residual(& self) -> Result<&str, String> {
+    pub(super) fn assert_residual(&self) -> Result<&str, String> {
         if self.residual == "" {
-            return Err("no residual".to_string())
-        }
-        else {
-            return Ok(self.residual)
+            return Err("no residual".to_string());
+        } else {
+            return Ok(self.residual);
         }
     }
-}
+}

src/vcd/types.rs

@@ -4,9 +4,9 @@
 // This program is distributed under both the GPLV3 license
 // and the YEHOWSHUA license, both of which can be found at
 // the root of the folder containing the sources for this program.
+use super::signal::{Signal, SignalEnum};
 use chrono::prelude::{DateTime, Utc};
 use num::BigUint;
-use super::signal::{Signal, SignalEnum};
 
 #[derive(Debug)]
 pub struct Version(pub String);
@@ -63,7 +63,7 @@ pub struct VCD {
     pub(super) all_signals: Vec<SignalEnum>,
     pub(super) all_scopes: Vec<Scope>,
     pub(super) root_scopes: Vec<ScopeIdx>,
-    pub(super) largest_timestamp: Option<BigUint>
+    pub(super) largest_timestamp: Option<BigUint>,
 }
 
 impl VCD {
@@ -106,7 +106,7 @@ impl VCD {
         // dereference signal if Signal::Alias, or keep idx if Signal::Data
         let signal_idx = match signal {
             SignalEnum::Data { self_idx, .. } => *self_idx,
-            SignalEnum::Alias {signal_alias, .. } => *signal_alias,
+            SignalEnum::Alias { signal_alias, .. } => *signal_alias,
         };
 
         // Should now  point to Signal::Data variant, or else there's an error