From f41f180655f35e1e3da7948d736894fcc4345d51 Mon Sep 17 00:00:00 2001
From: Brian Cully <bjc@spork.org>
Date: Sun, 31 Aug 2025 15:26:10 -0400
Subject: rustfmt

---
 src/lib.rs | 47 +++++++++++++++++++++++------------------------
 1 file changed, 23 insertions(+), 24 deletions(-)

(limited to 'src/lib.rs')

diff --git a/src/lib.rs b/src/lib.rs
index 27ff2f4..8aeaaff 100755
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,7 +12,10 @@ pub struct ExportedInstructionPointer {
 
 impl From<&forth::vm::InstructionPointer> for ExportedInstructionPointer {
     fn from(ip: &forth::vm::InstructionPointer) -> Self {
-        Self { word: ip.word, offset: ip.offset }
+        Self {
+            word: ip.word,
+            offset: ip.offset,
+        }
     }
 }
 
@@ -108,21 +111,25 @@ pub struct ExportedVM {
 #[wasm_bindgen]
 impl ExportedVM {
     fn new() -> Self {
-        Self { annos: vec![], vm: None }
+        Self {
+            annos: vec![],
+            vm: None,
+        }
     }
 
     pub fn compile(&mut self, text: &str) -> bool {
         let mut comp = forth::compiler::Compiler::new(text);
         if let Err(e) = comp.compile() {
             error!("couldn't compile program text: {e:?}");
-            return false
+            return false;
         }
-        self.annos =
-            comp.annotations.iter()
-                .map(|word_anno| -> ExportedWordAnnotations {
-                    word_anno.iter().map(|a| a.into()).collect()
-                })
-                .collect();
+        self.annos = comp
+            .annotations
+            .iter()
+            .map(|word_anno| -> ExportedWordAnnotations {
+                word_anno.iter().map(|a| a.into()).collect()
+            })
+            .collect();
         let vm = forth::vm::VM::new(comp.wordlist);
         let _ = self.vm.insert(vm);
         true
@@ -130,14 +137,14 @@ impl ExportedVM {
 
     pub fn tick(&mut self) -> Result<bool, String> {
         let Some(vm) = &mut self.vm else {
-            return Err("no vm".to_string())
+            return Err("no vm".to_string());
         };
         vm.tick().map_err(|err| format!("runtime error: {err:?}"))
     }
 
     pub fn run(&mut self) -> Result<usize, String> {
         let Some(vm) = &mut self.vm else {
-            return Err("no vm".to_string())
+            return Err("no vm".to_string());
         };
 
         vm.ip.word = 0;
@@ -146,17 +153,13 @@ impl ExportedVM {
     }
 
     pub fn stack(&self) -> Vec<forth::vm::DataStackType> {
-        let Some(vm) = &self.vm else {
-            return vec![]
-        };
+        let Some(vm) = &self.vm else { return vec![] };
 
         vm.stack.0.clone()
     }
 
     pub fn wordlist(&self) -> Vec<ExportedByteCode> {
-        let Some(vm) = &self.vm else {
-            return vec![]
-        };
+        let Some(vm) = &self.vm else { return vec![] };
 
         vm.wordlist.iter().map(|bc| bc.into()).collect()
     }
@@ -170,17 +173,13 @@ impl ExportedVM {
     }
 
     pub fn callstack(&self) -> Vec<ExportedInstructionPointer> {
-        let Some(vm) = &self.vm else {
-            return vec![]
-        };
-        vm.callstack.0.iter()
-            .map(|ip| ip.into())
-            .collect()
+        let Some(vm) = &self.vm else { return vec![] };
+        vm.callstack.0.iter().map(|ip| ip.into()).collect()
     }
 
     pub fn ip(&self) -> ExportedInstructionPointer {
         let Some(vm) = &self.vm else {
-            return ExportedInstructionPointer { word: 0, offset: 0 }
+            return ExportedInstructionPointer { word: 0, offset: 0 };
         };
         (&vm.ip).into()
     }
-- 
cgit v1.3