From 21f06825006a72c879f94a5f1a729e66c895fdb0 Mon Sep 17 00:00:00 2001 From: Yehowshua Immanuel Date: Tue, 2 Aug 2022 19:31:35 -0400 Subject: [PATCH] fixed most warnings --- Cargo.toml | 2 +- src/main.rs | 1 - src/test/files.rs | 6 +-- src/vcd/parse.rs | 14 +++--- src/vcd/parse/combinator_atoms.rs | 18 +------- src/vcd/parse/events.rs | 74 ++++++++++++++----------------- src/vcd/parse/metadata.rs | 40 ++++++++--------- src/vcd/parse/scopes.rs | 55 +++++++++++------------ src/vcd/reader.rs | 20 +++------ src/vcd/types.rs | 40 ++++++++--------- 10 files changed, 116 insertions(+), 154 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 18c1c50..e1c9d90 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "VCDViewer" +name = "fastwave" version = "0.1.0" edition = "2021" diff --git a/src/main.rs b/src/main.rs index a84f406..aab1585 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,7 +2,6 @@ use std::{fs::File}; use clap::Parser; pub mod test; -use test::*; pub mod vcd; use vcd::parse_vcd; diff --git a/src/test/files.rs b/src/test/files.rs index 6498b8c..375de49 100644 --- a/src/test/files.rs +++ b/src/test/files.rs @@ -1,6 +1,6 @@ // TODO: we should eventually be able to only test on just // the files const -pub const files : [&str; 30] = [ +pub const FILES : [&str; 30] = [ "./test-vcd-files/aldec/SPI_Write.vcd", "./test-vcd-files/ghdl/alu.vcd", "./test-vcd-files/ghdl/idea.vcd", @@ -34,7 +34,7 @@ pub const files : [&str; 30] = [ "./test-vcd-files/xilinx_isim/test2x2_regex22_string1.vcd" ]; -pub const good_date_files : [&str; 24] = [ +pub const GOOD_DATE_FILES : [&str; 24] = [ "./test-vcd-files/aldec/SPI_Write.vcd", "./test-vcd-files/ghdl/alu.vcd", "./test-vcd-files/ghdl/idea.vcd", @@ -61,7 +61,7 @@ pub const good_date_files : [&str; 24] = [ "./test-vcd-files/xilinx_isim/test2x2_regex22_string1.vcd" ]; -pub const bad_date_files : [&str; 6] = [ +pub const BAD_DATE_FILES : [&str; 6] = [ "./test-vcd-files/ncsim/ffdiv_32bit_tb.vcd", "./test-vcd-files/quartus/mipsHardware.vcd", "./test-vcd-files/quartus/wave_registradores.vcd", diff --git a/src/vcd/parse.rs b/src/vcd/parse.rs index acdcf86..320f8bb 100644 --- a/src/vcd/parse.rs +++ b/src/vcd/parse.rs @@ -19,8 +19,6 @@ use scopes::*; mod events; use events::*; -use function_name::named; - pub fn parse_vcd(file : File) -> Result { let mut word_gen = WordReader::new(file); @@ -30,7 +28,7 @@ pub fn parse_vcd(file : File) -> Result { // respective signal indexes let mut signal_map = std::collections::HashMap::new(); - // after we parse metadata, we form VCD object + // after we parse metadata, we form the VCD object let mut vcd = VCD{ metadata : header, timeline : vec![], @@ -40,7 +38,7 @@ pub fn parse_vcd(file : File) -> Result { scope_roots : vec![], }; - parse_scopes(&mut word_gen, None, &mut vcd, &mut signal_map)?; + parse_scopes(&mut word_gen, &mut vcd, &mut signal_map)?; parse_events(&mut word_gen, &mut vcd, &mut signal_map)?; Ok(vcd) @@ -56,7 +54,7 @@ mod tests { // TODO: eventually, once all dates pass, merge the following // two loops // testing dates - for file in test::good_date_files { + for file in test::GOOD_DATE_FILES { let metadata = parse_metadata( &mut WordReader::new( File::open(file) @@ -67,7 +65,7 @@ mod tests { assert!(metadata.unwrap().date.is_some()); } - for file in test::files { + for file in test::FILES { let metadata = parse_metadata( &mut WordReader::new( File::open(file) @@ -76,7 +74,7 @@ mod tests { ); assert!(metadata.is_ok()); - let (scalar, timescale) = metadata.unwrap().timescale; + let (scalar, _timescale) = metadata.unwrap().timescale; assert!(scalar.is_some()); } @@ -85,7 +83,7 @@ mod tests { #[test] fn scopes() { // see if we can parse all signal trees successfully - for file_name in test::files { + for file_name in test::FILES { let file = File::open(file_name).unwrap(); let vcd = parse_vcd(file); diff --git a/src/vcd/parse/combinator_atoms.rs b/src/vcd/parse/combinator_atoms.rs index ee180ad..32813fc 100644 --- a/src/vcd/parse/combinator_atoms.rs +++ b/src/vcd/parse/combinator_atoms.rs @@ -14,7 +14,7 @@ pub(super) fn take_until<'a>(word : &'a str, pattern : u8) -> ParseResult<'a> { let mut new_start = 0; for chr in word.as_bytes() { - if (*chr == pattern) { + if *chr == pattern { break } else { @@ -30,25 +30,11 @@ pub(super) fn take_until<'a>(word : &'a str, pattern : u8) -> ParseResult<'a> { } -// TODO: if I end up using simulator specific date parsers, ``take_until`` may -// suffice rendering this function obselete, at which point I should delete it. -pub(super) fn truncate_last_chr_when<'a>(word : &'a str, cond : fn(u8) -> bool) -> &'a str { - let last_chr = word.as_bytes().last().unwrap(); - let mut new_end_index = word.len(); - - if cond(*last_chr) { - new_end_index -= 1; - } - - return &word[0..new_end_index] - -} - pub(super) fn take_while<'a>(word : &'a str, cond : fn(u8) -> bool) -> ParseResult<'a> { let mut new_start = 0; for chr in word.as_bytes() { - if (cond(*chr)) { + if cond(*chr) { new_start += 1; } else { diff --git a/src/vcd/parse/events.rs b/src/vcd/parse/events.rs index 1ff3ed6..3b484c4 100644 --- a/src/vcd/parse/events.rs +++ b/src/vcd/parse/events.rs @@ -1,11 +1,9 @@ //! part of the vcd parser that handles parsing the signal tree and //! building the resulting signal tree -use function_name::named; - use super::*; #[derive(Debug)] -pub(super) enum BinaryParserErrTypes {x_value, z_value, u_value, other_value(char), too_long} +pub(super) enum BinaryParserErrTypes {XValue, ZValue, UValue, OtherValue(char), TooLong} // We build a quick and not so dirty bit string parser. fn base2_str_to_byte(word : &[u8]) -> Result { @@ -14,10 +12,7 @@ fn base2_str_to_byte(word : &[u8]) -> Result { // shouldn't have more than 8 chars in str let len = word.len(); if len > 8 { - let (f, l )= (file!(), line!()); - let err = format!( - "Error near {f}:{l}. Base2 string has length {len} > 8."); - return Err(BinaryParserErrTypes::too_long) + return Err(BinaryParserErrTypes::TooLong) } let bit_lut = [ @@ -35,10 +30,10 @@ fn base2_str_to_byte(word : &[u8]) -> Result { match chr { b'1' => {val = bit_lut[idx] | val} b'0' => {} - b'x' | b'X' => {return Err(BinaryParserErrTypes::x_value)} - b'z' | b'Z' => {return Err(BinaryParserErrTypes::z_value)} - b'u' | b'U' => {return Err(BinaryParserErrTypes::u_value)} - _ => {return Err(BinaryParserErrTypes::other_value(*chr as char))} + b'x' | b'X' => {return Err(BinaryParserErrTypes::XValue)} + b'z' | b'Z' => {return Err(BinaryParserErrTypes::ZValue)} + b'u' | b'U' => {return Err(BinaryParserErrTypes::UValue)} + _ => {return Err(BinaryParserErrTypes::OtherValue(*chr as char))} } } @@ -48,7 +43,7 @@ fn base2_str_to_byte(word : &[u8]) -> Result { fn binary_str_to_vec_u8(binary_str : &str) -> Result, BinaryParserErrTypes> { let mut vec_u8 : Vec = Vec::new(); - let mut binary_str_as_bytes = binary_str.as_bytes(); + let binary_str_as_bytes = binary_str.as_bytes(); let mut tail_idx = binary_str_as_bytes.len(); // clamp head if provided binary str is less than 8 long @@ -57,7 +52,7 @@ fn binary_str_to_vec_u8(binary_str : &str) -> Result, BinaryParserErrTyp {binary_str_as_bytes.len() - 8} else {0}; - while {tail_idx > 0} { + while tail_idx > 0 { let curr_b_val = &binary_str_as_bytes[head_idx..tail_idx]; let val_u8 = base2_str_to_byte(curr_b_val)?; vec_u8.push(val_u8); @@ -81,11 +76,10 @@ fn binary_str_to_vec_u8(binary_str : &str) -> Result, BinaryParserErrTyp Ok(vec_u8) } -#[named] pub(super) fn parse_events<'a>( word_reader : &mut WordReader, vcd : &'a mut VCD, - signal_map : &mut HashMap + signal_map : &mut HashMap ) -> Result<(), String> { loop { @@ -110,7 +104,7 @@ pub(super) fn parse_events<'a>( // configurable. let (f, l )= (file!(), line!()); let start_idx = u32::try_from(vcd.timeline.len()).map_err( - |e| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?; + |_| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?; vcd.timeline_markers.push(StartIdx(start_idx)); vcd.timeline.append(&mut value); } @@ -119,7 +113,6 @@ pub(super) fn parse_events<'a>( "b" => { let binary_value = &word[1..]; let observed_num_bits = binary_value.len(); - let (f, l )= (file!(), line!()); let mut value_u8 : Vec = Vec::new(); let mut value_string = String::new(); @@ -131,9 +124,9 @@ pub(super) fn parse_events<'a>( // Or else, we we propagate up other errors. match binary_str_to_vec_u8(binary_value) { Ok(result) => {value_u8 = result;} - Err(BinaryParserErrTypes::x_value | - BinaryParserErrTypes::z_value | - BinaryParserErrTypes::u_value + Err(BinaryParserErrTypes::XValue | + BinaryParserErrTypes::ZValue | + BinaryParserErrTypes::UValue ) => { store_as_string = true; @@ -151,7 +144,7 @@ pub(super) fn parse_events<'a>( // lookup signal idx let (f, l )= (file!(), line!()); - let Signal_Idx(ref signal_idx) = signal_map.get(word).ok_or( + let SignalIdx(ref signal_idx) = signal_map.get(word).ok_or( format!("Error near {f}:{l}. Failed to lookup signal {word} at {cursor:?}"))?; // account for fact that signal idx could be an alias, so there @@ -161,8 +154,8 @@ pub(super) fn parse_events<'a>( let signal = vcd.all_signals.get(*signal_idx).unwrap(); match signal { Signal::Data {..} => {*signal_idx} - Signal::Alias {name, signal_alias} => { - let Signal_Idx(ref signal_idx) = signal_alias; + Signal::Alias {signal_alias, ..} => { + let SignalIdx(ref signal_idx) = signal_alias; signal_idx.clone() } @@ -174,7 +167,7 @@ pub(super) 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, + u8_timeline, u8_timeline_markers, string_timeline, string_timeline_markers, ..} => { if signal_error.is_some() {continue;} @@ -210,7 +203,7 @@ pub(super) fn parse_events<'a>( let (f, l )= (file!(), line!()); let timeline_idx = u32::try_from(vcd.timeline.len()).map_err( - |e| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?; + |_| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?; let timeline_idx = TimelineIdx(timeline_idx); if store_as_string { @@ -264,7 +257,7 @@ pub(super) fn parse_events<'a>( // lookup signal idx let hash = &word[1..]; let (f, l )= (file!(), line!()); - let Signal_Idx(ref signal_idx) = signal_map.get(hash).ok_or( + let SignalIdx(ref signal_idx) = signal_map.get(hash).ok_or( format!("Error near {f}:{l}. Failed to lookup signal {hash} at {cursor:?}"))?; // account for fact that signal idx could be an alias, so there @@ -274,8 +267,8 @@ pub(super) fn parse_events<'a>( let signal = vcd.all_signals.get(*signal_idx).unwrap(); match signal { Signal::Data {..} => {*signal_idx} - Signal::Alias {name, signal_alias} => { - let Signal_Idx(ref signal_idx) = signal_alias; + Signal::Alias {signal_alias, ..} => { + let SignalIdx(ref signal_idx) = signal_alias; signal_idx.clone() } @@ -287,7 +280,7 @@ pub(super) 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, ..} => { + u8_timeline, u8_timeline_markers, ..} => { // if this is a bad signal, go ahead and skip it if signal_error.is_some() {continue;} @@ -321,7 +314,7 @@ pub(super) fn parse_events<'a>( let (f, l )= (file!(), line!()); let timeline_idx = u32::try_from(vcd.timeline.len()).map_err( - |e| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?; + |_| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?; let timeline_idx = TimelineIdx(timeline_idx); u8_timeline_markers.push(timeline_idx); @@ -342,7 +335,7 @@ pub(super) fn parse_events<'a>( // lokup signal idx let hash = &word[1..]; let (f, l )= (file!(), line!()); - let Signal_Idx(ref signal_idx) = signal_map.get(hash).ok_or( + let SignalIdx(ref signal_idx) = signal_map.get(hash).ok_or( format!("Error near {f}:{l}. Failed to lookup signal {hash} at {cursor:?}"))?; // account for fact that signal idx could be an alias, so there @@ -352,8 +345,8 @@ pub(super) fn parse_events<'a>( let signal = vcd.all_signals.get(*signal_idx).unwrap(); match signal { Signal::Data {..} => {*signal_idx} - Signal::Alias {name, signal_alias} => { - let Signal_Idx(ref signal_idx) = signal_alias; + Signal::Alias {signal_alias, ..} => { + let SignalIdx(ref signal_idx) = signal_alias; signal_idx.clone() } @@ -365,7 +358,7 @@ pub(super) 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, ..} => { + u8_timeline, u8_timeline_markers, ..} => { // if this is a bad signal, go ahead and skip it if signal_error.is_some() {continue;} @@ -399,7 +392,7 @@ pub(super) fn parse_events<'a>( let (f, l )= (file!(), line!()); let timeline_idx = u32::try_from(vcd.timeline.len()).map_err( - |e| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?; + |_| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?; let timeline_idx = TimelineIdx(timeline_idx); u8_timeline_markers.push(timeline_idx); @@ -421,7 +414,7 @@ pub(super) fn parse_events<'a>( // lokup signal idx let hash = &word[1..]; let (f, l )= (file!(), line!()); - let Signal_Idx(ref signal_idx) = signal_map.get(hash).ok_or( + let SignalIdx(ref signal_idx) = signal_map.get(hash).ok_or( format!("Error near {f}:{l}. Failed to lookup signal {hash} at {cursor:?}"))?; // account for fact that signal idx could be an alias, so there @@ -431,8 +424,8 @@ pub(super) fn parse_events<'a>( let signal = vcd.all_signals.get(*signal_idx).unwrap(); match signal { Signal::Data {..} => {*signal_idx} - Signal::Alias {name, signal_alias} => { - let Signal_Idx(ref signal_idx) = signal_alias; + Signal::Alias {signal_alias, ..} => { + let SignalIdx(ref signal_idx) = signal_alias; signal_idx.clone() } @@ -444,8 +437,7 @@ pub(super) 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, ..} => { + string_timeline, string_timeline_markers, ..} => { // if this is a bad signal, go ahead and skip it if signal_error.is_some() {continue;} @@ -479,7 +471,7 @@ pub(super) fn parse_events<'a>( let (f, l )= (file!(), line!()); let timeline_idx = u32::try_from(vcd.timeline.len()).map_err( - |e| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?; + |_| format!("Error near {f}:{l}. Failed to convert from usize to u32."))?; let timeline_idx = TimelineIdx(timeline_idx); string_timeline_markers.push(timeline_idx); diff --git a/src/vcd/parse/metadata.rs b/src/vcd/parse/metadata.rs index 5d8c956..ef6ac5a 100644 --- a/src/vcd/parse/metadata.rs +++ b/src/vcd/parse/metadata.rs @@ -1,6 +1,5 @@ use chrono::prelude::*; use itertools::Itertools; -use std::fs::File; use function_name::named; use super::*; @@ -120,7 +119,7 @@ pub(super) fn parse_date( let year = { // check for another word in the file - let (word, cursor) = word_and_ctx5; + let (word, _) = word_and_ctx5; word.to_string() }; @@ -148,7 +147,7 @@ pub(super) fn parse_version(word_reader : &mut WordReader) -> Result Result<(Option Result<(Option {Ok(Timescale::fs)} - "ps" => {Ok(Timescale::ps)} - "ns" => {Ok(Timescale::ns)} - "us" => {Ok(Timescale::us)} - "ms" => {Ok(Timescale::ms)} - "s" => {Ok(Timescale::s)} + "fs" => {Ok(Timescale::Fs)} + "ps" => {Ok(Timescale::Ps)} + "ns" => {Ok(Timescale::Ns)} + "us" => {Ok(Timescale::Us)} + "ms" => {Ok(Timescale::Ms)} + "s" => {Ok(Timescale::S)} _ => {Err(err_msg.to_string())} }.unwrap(); @@ -195,11 +194,11 @@ pub(super) fn parse_timescale(word_reader : &mut WordReader) -> Result<(Option {Ok(Timescale::ps)} - "ns" => {Ok(Timescale::ns)} - "us" => {Ok(Timescale::us)} - "ms" => {Ok(Timescale::ms)} - "s" => {Ok(Timescale::s)} + "ps" => {Ok(Timescale::Ps)} + "ns" => {Ok(Timescale::Ns)} + "us" => {Ok(Timescale::Us)} + "ms" => {Ok(Timescale::Ms)} + "s" => {Ok(Timescale::S)} _ => {Err(err_msg.to_string())} }.unwrap(); @@ -208,12 +207,11 @@ pub(super) fn parse_timescale(word_reader : &mut WordReader) -> Result<(Option Result Result = Vec::new(); - for word in 0..5 { + for _ in 0..5 { let (word, cursor) = word_reader.next_word().expect(err_msg.as_str()); let word = word.to_string(); match word.as_str() { diff --git a/src/vcd/parse/scopes.rs b/src/vcd/parse/scopes.rs index f408634..3a65f6c 100644 --- a/src/vcd/parse/scopes.rs +++ b/src/vcd/parse/scopes.rs @@ -7,9 +7,9 @@ use super::*; #[named] pub(super) fn parse_var<'a>( word_reader : &mut WordReader, - parent_scope_idx : Scope_Idx, + parent_scope_idx : ScopeIdx, vcd : &'a mut VCD, - signal_map : &mut HashMap + signal_map : &mut HashMap ) -> Result<(), String> { let err = format!("reached end of file without parser leaving {}", function_name!()); let (word, cursor) = word_reader.next_word().ok_or(&err)?; @@ -18,14 +18,14 @@ pub(super) fn parse_var<'a>( // $var parameter 3 a IDLE $end // ^^^^^^^^^ - var_type let var_type = match word { - "integer" => {Ok(Sig_Type::Integer)} - "parameter" => {Ok(Sig_Type::Parameter)} - "real" => {Ok(Sig_Type::Real)} - "reg" => {Ok(Sig_Type::Reg)} - "string" => {Ok(Sig_Type::Str)} - "wire" => {Ok(Sig_Type::Wire)} - "tri1" => {Ok(Sig_Type::Tri1)} - "time" => {Ok(Sig_Type::Time)} + "integer" => {Ok(SigType::Integer)} + "parameter" => {Ok(SigType::Parameter)} + "real" => {Ok(SigType::Real)} + "reg" => {Ok(SigType::Reg)} + "string" => {Ok(SigType::Str)} + "wire" => {Ok(SigType::Wire)} + "tri1" => {Ok(SigType::Tri1)} + "time" => {Ok(SigType::Time)} _ => { let err = format!("found keyword `{word}` but expected one of {expected_types:?} on {cursor:?}"); Err(err) @@ -38,10 +38,10 @@ pub(super) fn parse_var<'a>( // $var parameter 3 a IDLE $end // ^ - no_bits let no_bits = match var_type { - Sig_Type::Integer | Sig_Type::Parameter | - Sig_Type::Real | Sig_Type::Reg | - Sig_Type::Wire | Sig_Type::Tri1 | - Sig_Type::Time => { + SigType::Integer | SigType::Parameter | + SigType::Real | SigType::Reg | + SigType::Wire | SigType::Tri1 | + SigType::Time => { let no_bits = word.parse::().expect(parse_err.as_str()); Some(no_bits) } @@ -51,7 +51,7 @@ pub(super) fn parse_var<'a>( // $var parameter 3 a IDLE $end // ^ - signal_alias - let (word, cursor) = word_reader.next_word().ok_or(&err)?; + let (word, _) = word_reader.next_word().ok_or(&err)?; let signal_alias = word.to_string(); // dbg!(&signal_alias); @@ -59,7 +59,7 @@ pub(super) fn parse_var<'a>( // ^^^^ - full_signal_name(can extend until $end) let mut full_signal_name = Vec::::new(); loop { - let (word, cursor) = word_reader.next_word().ok_or(&err)?; + let (word, _) = word_reader.next_word().ok_or(&err)?; match word { "$end" => {break} _ => {full_signal_name.push(word.to_string())} @@ -72,14 +72,14 @@ pub(super) fn parse_var<'a>( // map let (signal, signal_idx) = match signal_map.get(&signal_alias) { Some(ref_signal_idx) => { - let signal_idx = Signal_Idx(vcd.all_signals.len()); + let signal_idx = SignalIdx(vcd.all_signals.len()); let signal = Signal::Alias{ name: full_signal_name, signal_alias: *ref_signal_idx}; (signal, signal_idx) } None => { - let signal_idx = Signal_Idx(vcd.all_signals.len()); + let signal_idx = SignalIdx(vcd.all_signals.len()); signal_map.insert(signal_alias.to_string(), signal_idx); let signal = Signal::Data{ name: full_signal_name, @@ -97,7 +97,7 @@ pub(super) fn parse_var<'a>( }; vcd.all_signals.push(signal); - let Scope_Idx(parent_scope_idx_usize) = parent_scope_idx; + let ScopeIdx(parent_scope_idx_usize) = parent_scope_idx; let parent_scope = vcd.all_scopes.get_mut(parent_scope_idx_usize).unwrap(); parent_scope.child_signals.push(signal_idx); @@ -109,7 +109,7 @@ pub(super) fn parse_var<'a>( fn parse_orphaned_vars<'a>( word_reader : &mut WordReader, vcd : &'a mut VCD, - signal_map : &mut HashMap + signal_map : &mut HashMap ) -> Result<(), String> { // create scope for unscoped signals if such a scope does not // yet exist @@ -118,7 +118,7 @@ fn parse_orphaned_vars<'a>( // set default scope_idx to the count of existing scope as we // generally set scope.self_idx to the number of existing scopes // when that particular scope was inserted - let mut scope_idx = Scope_Idx(vcd.all_scopes.len()); + let mut scope_idx = ScopeIdx(vcd.all_scopes.len()); // Override scope_idx if we find a scope named "Orphaned Signals" // already exists @@ -181,9 +181,9 @@ fn parse_orphaned_vars<'a>( #[named] pub(super) fn parse_signal_tree<'a>( word_reader : &mut WordReader, - parent_scope_idx : Option, + parent_scope_idx : Option, vcd : &'a mut VCD, - signal_map : &mut HashMap + signal_map : &mut HashMap ) -> Result<(), String> { // $scope module reg_mag_i $end @@ -203,13 +203,13 @@ pub(super) fn parse_signal_tree<'a>( // ^^^^^^^^^ - scope name let (scope_name, _) = word_reader.next_word().ok_or(&err)?; - let curr_scope_idx = Scope_Idx(vcd.all_scopes.len()); + let curr_scope_idx = ScopeIdx(vcd.all_scopes.len()); // register this scope as a child of the current parent scope // if there is a parent scope, or else we register this scope as // root scope match parent_scope_idx { - Some(Scope_Idx(parent_scope_idx)) => { + Some(ScopeIdx(parent_scope_idx)) => { let parent_scope = vcd.all_scopes.get_mut(parent_scope_idx).unwrap(); parent_scope.child_scopes.push(curr_scope_idx); } @@ -277,14 +277,13 @@ pub(super) fn parse_signal_tree<'a>( #[named] pub(super) fn parse_scopes<'a>( word_reader : &mut WordReader, - parent_scope_idx : Option, vcd : &'a mut VCD, - signal_map : &mut HashMap + signal_map : &mut HashMap ) -> Result<(), String> { // get the current word let (f, l ) = (file!(), line!()); let msg = format!("Error near {f}:{l}. Current word empty!"); - let (word, cursor) = word_reader.curr_word().ok_or(msg)?; + let (word, _) = word_reader.curr_word().ok_or(msg)?; // we may have orphaned vars that occur before the first scope if word == "$var" { diff --git a/src/vcd/reader.rs b/src/vcd/reader.rs index d6437a9..7ae33e7 100644 --- a/src/vcd/reader.rs +++ b/src/vcd/reader.rs @@ -12,17 +12,9 @@ pub(super) struct Word(pub(super) usize); #[derive(Debug, Clone)] pub(super) struct Cursor(pub(super) Line, pub(super) Word); -impl Cursor { - pub(super) fn error(&self, word : &str) -> Result<(), String> { - let Cursor(Line(line_no), Word(word_no)) = self; - Err(format!("Error on word '{word}' {word_no} words into line {line_no}!")) - } - -} - pub struct WordReader { reader : io::BufReader, - EOF : bool, + eof : bool, buffers : Vec, curr_line : usize, str_slices : VecDeque<(*const u8, usize, Cursor)>, @@ -31,10 +23,10 @@ pub struct WordReader { impl WordReader { pub(super) fn new(file : File) -> WordReader { - let mut reader = io::BufReader::new(file); + let reader = io::BufReader::new(file); WordReader { reader : reader, - EOF : false, + eof : false, buffers : vec![], curr_line : 0, str_slices : VecDeque::new(), @@ -48,7 +40,7 @@ impl WordReader { if self.str_slices.is_empty() { self.buffers.clear(); - if self.EOF {return None} + if self.eof {return None} let num_buffers = 10; @@ -60,11 +52,11 @@ impl WordReader { // if we've reached the end of the file on the first attempt to read // a line in this for loop, no further attempts are necessary and we if bytes_read == 0 { - self.EOF = true; + self.eof = true; break; } - let mut words = self.buffers[buf_idx].split_ascii_whitespace(); + let words = self.buffers[buf_idx].split_ascii_whitespace(); for word in words.enumerate() { let (word_idx, word) = word; diff --git a/src/vcd/types.rs b/src/vcd/types.rs index 6c13095..0a9e004 100644 --- a/src/vcd/types.rs +++ b/src/vcd/types.rs @@ -4,7 +4,7 @@ use chrono::prelude::*; pub(super) struct Version(pub String); #[derive(Debug)] -pub(super) enum Timescale {fs, ps, ns, us, ms, s, unit} +pub(super) enum Timescale {Fs, Ps, Ns, Us, Ms, S, Unit} #[derive(Debug)] pub(super) struct Metadata { @@ -13,10 +13,10 @@ pub(super) struct Metadata { pub(super) timescale : (Option, Timescale)} #[derive(Debug, Copy, Clone)] -pub(super) struct Scope_Idx(pub(super) usize); +pub(super) struct ScopeIdx(pub(super) usize); #[derive(Debug, Copy, Clone)] -pub(super) struct Signal_Idx(pub(super) usize); +pub(super) struct SignalIdx(pub(super) usize); #[derive(Debug, Copy, Clone)] pub(super) struct TimelineIdx(pub(super) u32); @@ -25,13 +25,13 @@ pub(super) struct TimelineIdx(pub(super) u32); pub struct StartIdx(pub(super) u32); #[derive(Debug)] -pub(super) enum Sig_Type {Integer, Parameter, Real, Reg, Str, Wire, Tri1, Time} +pub(super) enum SigType {Integer, Parameter, Real, Reg, Str, Wire, Tri1, Time} #[derive(Debug)] pub(super) enum Signal{ Data{ name : String, - sig_type : Sig_Type, + sig_type : SigType, // I've seen a 0 bit signal parameter in a xilinx // simulation before that gets assigned 1 bit values. // I consider this to be bad behavior. We capture such @@ -39,28 +39,28 @@ pub(super) enum Signal{ signal_error : Option, num_bits : Option, // TODO : may be able to remove self_idx - self_idx : Signal_Idx, + self_idx : SignalIdx, // we could encounter a mix of pure values and strings // for the same signal timeline u8_timeline : Vec, - u8_timeline_markers : Vec<(TimelineIdx)>, + u8_timeline_markers : Vec, string_timeline : Vec, - string_timeline_markers : Vec<(TimelineIdx)>, - scope_parent : Scope_Idx}, + string_timeline_markers : Vec, + scope_parent : ScopeIdx}, Alias{ name : String, - signal_alias : Signal_Idx} + signal_alias : SignalIdx} } #[derive(Debug)] pub(super) struct Scope { pub(super) name : String, - pub(super) parent_idx : Option, - pub(super) self_idx : Scope_Idx, + pub(super) parent_idx : Option, + pub(super) self_idx : ScopeIdx, - pub(super) child_signals : Vec, - pub(super) child_scopes : Vec} + pub(super) child_signals : Vec, + pub(super) child_scopes : Vec} // TODO: document how timeline is represented @@ -71,27 +71,27 @@ pub struct VCD { pub timeline_markers : Vec, pub(super) all_signals : Vec, pub(super) all_scopes : Vec, - pub(super) scope_roots : Vec} + pub(super) scope_roots : Vec} impl VCD { // TODO : make this a generic traversal function that applies specified // functions upon encountering scopes and signals fn print_scope_tree( &self, - root_scope_idx : Scope_Idx, + root_scope_idx : ScopeIdx, depth : usize) { let all_scopes = &self.all_scopes; let all_signals = &self.all_signals; let indent = " ".repeat(depth * 4); - let Scope_Idx(root_scope_idx) = root_scope_idx; + let ScopeIdx(root_scope_idx) = root_scope_idx; let root_scope = &all_scopes[root_scope_idx]; let root_scope_name = &root_scope.name; println!("{indent}scope: {root_scope_name}"); - for Signal_Idx(ref signal_idx) in &root_scope.child_signals { + for SignalIdx(ref signal_idx) in &root_scope.child_signals { let child_signal = &all_signals[*signal_idx]; let name = match child_signal { Signal::Data{name, ..} => {name} @@ -123,14 +123,12 @@ impl VCD { Signal::Alias {..} => {} Signal::Data { name, - sig_type, - num_bits, self_idx, u8_timeline, .. } => { if u8_timeline.len() > max_len { max_len = u8_timeline.len(); - let Signal_Idx(idx_usize) = self_idx; + let SignalIdx(idx_usize) = self_idx; idx = *idx_usize; signal_name = name.clone(); }