From 49d103fd56e0c0425fb0fd8474916064354bf5d8 Mon Sep 17 00:00:00 2001
From: Yehowshua Immanuel <yehowshua@theperfect.computer>
Date: Tue, 12 Jul 2022 20:02:45 -0400
Subject: [PATCH] some incomplete changes

---
 src/main.rs               |  3 ++-
 src/vcd/parse.rs          | 33 ++++++++++++++++++++++++++++++++-
 src/vcd/parse/metadata.rs |  2 +-
 src/vcd/reader.rs         | 12 ++++++++++--
 src/vcd/types.rs          | 16 ++++++++--------
 5 files changed, 53 insertions(+), 13 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 45723cd..2d87fcd 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,7 +5,7 @@ pub mod test;
 use test::*;
 
 pub mod vcd;
-use vcd::*;
+use vcd::parse_vcd;
 
 #[derive(Parser)]
 struct Cli {
@@ -16,6 +16,7 @@ struct Cli {
 fn main() -> std::io::Result<()> {
     let args = Cli::parse();
 
+
     let file = File::open(&args.path)?;
     parse_vcd(file);
 
diff --git a/src/vcd/parse.rs b/src/vcd/parse.rs
index 5fc9a69..f507f4f 100644
--- a/src/vcd/parse.rs
+++ b/src/vcd/parse.rs
@@ -14,12 +14,43 @@ use types::*;
 mod metadata;
 use metadata::*;
 
+// use function_name::named;
+
+#[named]
+fn parse_signal_tree<'a>(
+    word_reader : &mut WordReader,
+    vcd         : &'a mut VCD
+) -> Result<&'a mut VCD, String> {
+    let err : Result<&'a mut VCD, String> = Err(format!("reached end of file without parser leaving {}", function_name!()));
+    // we assume we've already seen a `$scope` once
+    // by the time we reach this function
+    // let scope_name = 
+    loop {
+        let word = word_reader.next_word();
+
+        // if there isn't another word left in the file, then we exit
+        if word.is_none() {
+            return err;
+        }
+    }
+    Ok(vcd)
+}
+
 
 pub fn parse_vcd(file : File) {
     let mut word_gen = WordReader::new(file);
 
     let header = parse_metadata(&mut word_gen).unwrap();
-    dbg!(header);
+    dbg!(&header);
+
+    // let (word, cursor) = word_gen.next_word().unwrap();
+    // cursor.error(word).unwrap();
+
+    let mut vcd = VCD{
+        metadata: header,
+        all_signals: vec![],
+        all_scopes: vec![]
+    };
 }
 
 #[cfg(test)]
diff --git a/src/vcd/parse/metadata.rs b/src/vcd/parse/metadata.rs
index 8f07566..7e0cc91 100644
--- a/src/vcd/parse/metadata.rs
+++ b/src/vcd/parse/metadata.rs
@@ -1,7 +1,7 @@
 use chrono::prelude::*;
 use itertools::Itertools;
 use std::fs::File;
-use ::function_name::named;
+use function_name::named;
 
 use super::*;
 
diff --git a/src/vcd/reader.rs b/src/vcd/reader.rs
index b9c85e4..f361716 100644
--- a/src/vcd/reader.rs
+++ b/src/vcd/reader.rs
@@ -12,6 +12,14 @@ struct Word(usize);
 #[derive(Debug)]
 pub struct Cursor(Line, 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<File>,
     EOF          : bool,
@@ -21,7 +29,7 @@ pub struct WordReader {
 }
 
 impl WordReader {
-    pub fn new(file : File) -> WordReader {
+    pub(super) fn new(file : File) -> WordReader {
         let mut reader = io::BufReader::new(file);
         WordReader {
             reader       : reader,
@@ -32,7 +40,7 @@ impl WordReader {
         }
     }
 
-    pub fn next_word(&mut self) -> Option<(&str, Cursor)> {
+    pub(super) fn next_word(&mut self) -> Option<(&str, Cursor)> {
         // if there are no more words, attempt to read more content
         // from the file
         if self.str_slices.is_empty() {
diff --git a/src/vcd/types.rs b/src/vcd/types.rs
index ed87467..858c122 100644
--- a/src/vcd/types.rs
+++ b/src/vcd/types.rs
@@ -15,13 +15,13 @@ pub(super) struct Metadata {
     pub(super) timescale : (Option<u32>, Timescale)}
 
 #[derive(Debug)]
-struct Scope_Idx(usize);
+pub(super) struct Scope_Idx(usize);
 
 #[derive(Debug)]
-struct Signal_Idx(usize);
+pub(super) struct Signal_Idx(usize);
 
 #[derive(Debug)]
-enum SignalGeneric{
+pub(super) enum SignalGeneric{
     Signal{
         name           : String,
         timeline       : BTreeMap<BigInt, BigInt>,
@@ -32,18 +32,18 @@ enum SignalGeneric{
 }
 
 #[derive(Debug)]
-struct Scope {
+pub(super) struct Scope {
     name          : String,
     child_signals : Vec<Signal_Idx>,
     child_scopes  : Vec<Scope_Idx>}
 
 
 #[derive(Debug)]
-struct VCD {
-    metadata    : Metadata,
-    all_signals : Vec<SignalGeneric>,
+pub struct VCD {
+    pub(super) metadata    : Metadata,
+    pub(super) all_signals : Vec<SignalGeneric>,
     // the root scope should always be placed at index 0
-    all_scopes  : Vec<Scope>}
+    pub(super) all_scopes  : Vec<Scope>}
 
 impl VCD {
     pub fn new() -> Self {