1 files changed, 200 insertions, 0 deletions

diff --git a/src/parse.rs b/src/parse.rs
new file mode 100644
index 0000000..5b613ca
--- /dev/null
+++ b/src/parse.rs
@@ -0,0 +1,200 @@
+use crate::{lex::Stanza, Dict};
+
+pub struct ParseState {
+    dict: Dict,
+    status: Status,
+    current_entry: EntryBuilder,
+    errors: Vec<ParseError>,
+}
+
+#[derive(Debug)]
+enum ParseError {
+    Build(EntryBuilderError),
+    UndefinedState(Status, EntryBuilder, Stanza),
+}
+
+impl ParseState {
+    pub fn new() -> Self {
+        Self {
+            dict: Dict::new(),
+            status: Status::Start,
+            current_entry: EntryBuilder::new(),
+            errors: Vec::new(),
+        }
+    }
+
+    pub fn advance(mut self, stanza: Stanza) -> Self {
+        match (self.status, stanza) {
+            (Status::Start, Stanza::Entry(e)) => {
+                self.current_entry.set_name(e);
+                self.status = Status::ContainsName;
+            }
+            (Status::ContainsName, Stanza::Defn(d)) => {
+                self.current_entry.push_defn(d);
+                self.status = Status::ContainsOneDefn;
+            }
+            (Status::ContainsOneDefn | Status::ContainsMulDefn, Stanza::Defn(d)) => {
+                self.current_entry.push_defn(d);
+                self.status = Status::ContainsMulDefn;
+            }
+            (
+                Status::ContainsOneDefn | Status::ContainsMulDefn | Status::ContainsSynonym,
+                Stanza::Note(n),
+            ) => {
+                self.current_entry.set_note(n);
+                self.status = Status::ContainsNote;
+            }
+            (
+                Status::ContainsOneDefn | Status::ContainsMulDefn | Status::ContainsNote,
+                Stanza::Synonym(s),
+            ) => {
+                self.current_entry.set_synonym(s);
+                self.status = Status::ContainsSynonym;
+            }
+            (
+                Status::ContainsOneDefn
+                | Status::ContainsMulDefn
+                | Status::ContainsNote
+                | Status::ContainsSynonym,
+                Stanza::Entry(e),
+            ) => {
+                // flush the current entry
+                match self.current_entry.build() {
+                    Ok(entry) => self.dict.insert(entry.name, entry.into()),
+                    Err(b) => self.register_error(ParseError::Build(b)),
+                };
+
+                // begin with the new one
+                self.current_entry.clear();
+                self.current_entry.set_name(e);
+                self.status = Status::ContainsName;
+            }
+            (Status::ContainsName, Stanza::Entry(e)) => {
+                // dump unfinished entry and enter new entry
+                self.current_entry.clear();
+                self.current_entry.set_name(e);
+                self.status = Status::ContainsName;
+            }
+            (_, new_entry) => {
+                // any other states means our parser is entering undefined teritorry
+                // register an error if we have anything in current_entry
+                self.register_undefined_state_error(new_entry);
+                // and set the status to Start and fast forward to the next entry
+                self.current_entry.clear();
+                self.status = Status::Start;
+            }
+        }
+        self
+    }
+
+    fn register_error(&mut self, error: ParseError) {
+        self.errors.push(error)
+    }
+
+    fn register_undefined_state_error(&mut self, new_entry: Stanza) {
+        self.register_error(ParseError::UndefinedState(
+            self.status,
+            self.current_entry.clone(),
+            new_entry,
+        ));
+    }
+
+    pub fn finish(self) -> Dict {
+        self.dict
+    }
+
+    pub fn dump(&self) {
+        for err in &self.errors {
+            eprintln!("{err:?}");
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+enum Status {
+    // ready to accept a new entry
+    Start,
+    // ready to accept a defn
+    ContainsName,
+    // can accept notes or synonyms, or flush this entry
+    ContainsOneDefn,
+    // can accept notes or synonyms, or flush this entry
+    ContainsMulDefn,
+    // can accept a synonym
+    ContainsNote,
+    // can accept a note
+    ContainsSynonym,
+    // mangled stanza, skip until the next entry occurs
+}
+
+#[derive(Debug, Clone)]
+struct Entry {
+    name: &'static str,
+    defn: Vec<&'static str>,
+    note: Option<&'static str>,
+    synonym: Option<&'static str>,
+}
+
+impl From<Entry> for crate::DictValue {
+    fn from(entry: Entry) -> Self {
+        Self {
+            defn: entry.defn,
+            note: entry.note,
+            synonym: entry.synonym,
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+struct EntryBuilder {
+    name: Option<&'static str>,
+    defn: Vec<&'static str>,
+    note: Option<&'static str>,
+    synonym: Option<&'static str>,
+}
+
+#[derive(Debug)]
+enum EntryBuilderError {
+    MissingField(&'static str),
+}
+
+impl EntryBuilder {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn clear(&mut self) {
+        *self = Self::default();
+    }
+
+    fn set_name(&mut self, name: &'static str) {
+        self.name = Some(name);
+    }
+
+    fn push_defn(&mut self, defn: &'static str) {
+        self.defn.push(defn);
+    }
+
+    fn set_note(&mut self, note: &'static str) {
+        self.note = Some(note);
+    }
+
+    fn set_synonym(&mut self, synonym: &'static str) {
+        self.synonym = Some(synonym);
+    }
+
+    fn build(&self) -> Result<Entry, EntryBuilderError> {
+        let name = self.name.ok_or(EntryBuilderError::MissingField("name"))?;
+        let defn = if self.defn.is_empty() {
+            return Err(EntryBuilderError::MissingField("defn"));
+        } else {
+            self.defn.clone()
+        };
+        Ok(Entry {
+            name,
+            defn,
+            note: self.note,
+            synonym: self.synonym,
+        })
+    }
+}