1 files changed, 39 insertions, 39 deletions

diff --git a/src/lib.rs b/src/lib.rs
index bb8e638..60a406f 100755
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,8 +10,8 @@ pub struct ExportedInstructionPointer {
     pub offset: usize,
 }
 
-impl From<&forth::interp::InstructionPointer> for ExportedInstructionPointer {
-    fn from(ip: &forth::interp::InstructionPointer) -> Self {
+impl From<&forth::vm::InstructionPointer> for ExportedInstructionPointer {
+    fn from(ip: &forth::vm::InstructionPointer) -> Self {
         Self { word: ip.word, offset: ip.offset }
     }
 }
@@ -22,8 +22,8 @@ impl From<&forth::interp::InstructionPointer> for ExportedInstructionPointer {
 pub struct ExportedByteCode(Vec<String>);
 
 impl ExportedByteCode {
-    fn tr_op(op: &forth::interp::OpCode) -> String {
-        use forth::interp::OpCode::*;
+    fn tr_op(op: &forth::vm::OpCode) -> String {
+        use forth::vm::OpCode::*;
         let s = match op {
             If(t, None) => format!("If({}, none)", t),
             If(t, Some(f)) => format!("If({}, {})", t, f),
@@ -35,8 +35,8 @@ impl ExportedByteCode {
     }
 }
 
-impl From<&forth::interp::ByteCode> for ExportedByteCode {
-    fn from(v: &forth::interp::ByteCode) -> Self {
+impl From<&forth::vm::ByteCode> for ExportedByteCode {
+    fn from(v: &forth::vm::ByteCode) -> Self {
         Self(v.iter().map(Self::tr_op).collect())
     }
 }
@@ -60,8 +60,8 @@ pub struct ExportedAnnotation {
     pub end: usize,
 }
 
-impl From<&forth::parser::Annotation> for ExportedAnnotation {
-    fn from(v: &forth::parser::Annotation) -> Self {
+impl From<&forth::compiler::Annotation> for ExportedAnnotation {
+    fn from(v: &forth::compiler::Annotation) -> Self {
         Self {
             start: v.loc.0,
             end: v.loc.1,
@@ -92,65 +92,65 @@ impl ExportedWordAnnotations {
 }
 
 #[wasm_bindgen]
-pub struct ExportedInterp {
+pub struct ExportedVM {
     annos: Vec<ExportedWordAnnotations>,
-    i: Option<forth::interp::Interp>,
+    vm: Option<forth::vm::VM>,
 }
 
 #[wasm_bindgen]
-impl ExportedInterp {
+impl ExportedVM {
     fn new() -> Self {
-        Self { annos: vec![], i: None }
+        Self { annos: vec![], vm: None }
     }
 
     pub fn compile(&mut self, text: &str) -> bool {
-        let mut p = forth::parser::Parser::new(&text);
-        if let Err(e) = p.parse() {
-            error!("couldn't parse program text: {:?}", e);
+        let mut comp = forth::compiler::Compiler::new(&text);
+        if let Err(e) = comp.compile() {
+            error!("couldn't compile program text: {:?}", e);
             return false
         }
         self.annos =
-            p.annotations.iter()
+            comp.annotations.iter()
                 .map(|word_anno| -> ExportedWordAnnotations {
                     word_anno.into_iter().map(|a| a.into()).collect()
                 })
                 .collect();
-        let interp = forth::interp::Interp::new(p.wordlist);
-        let _ = self.i.insert(interp);
+        let vm = forth::vm::VM::new(comp.wordlist);
+        let _ = self.vm.insert(vm);
         true
     }
 
     pub fn tick(&mut self) -> Result<bool, String> {
-        let Some(interp) = &mut self.i else {
-            return Err("no interpreter".to_string())
+        let Some(vm) = &mut self.vm else {
+            return Err("no vm".to_string())
         };
-        interp.tick().or_else(|err| Err(format!("runtime error: {:?}", err)))
+        vm.tick().or_else(|err| Err(format!("runtime error: {:?}", err)))
     }
 
     pub fn run(&mut self) -> Result<usize, String> {
-        let Some(interp) = &mut self.i else {
-            return Err("no interpreter".to_string())
+        let Some(vm) = &mut self.vm else {
+            return Err("no vm".to_string())
         };
 
-        interp.ip.word = 0;
-        interp.ip.offset = 0;
-        interp.run().or_else(|err| Err(format!("runtime error: {:?}", err)))
+        vm.ip.word = 0;
+        vm.ip.offset = 0;
+        vm.run().or_else(|err| Err(format!("runtime error: {:?}", err)))
     }
 
     pub fn stack(&self) -> Vec<i32> {
-        let Some(interp) = &self.i else {
+        let Some(vm) = &self.vm else {
             return vec![]
         };
 
-        return interp.stack.0.clone()
+        return vm.stack.0.clone()
     }
 
     pub fn wordlist(&self) -> Vec<ExportedByteCode> {
-        let Some(interp) = &self.i else {
+        let Some(vm) = &self.vm else {
             return vec![]
         };
 
-        interp.wordlist.iter().map(|bc| bc.into()).collect()
+        vm.wordlist.iter().map(|bc| bc.into()).collect()
     }
 
     pub fn annotations(&self) -> Vec<ExportedWordAnnotations> {
@@ -162,33 +162,33 @@ impl ExportedInterp {
     }
 
     pub fn callstack(&self) -> Vec<ExportedInstructionPointer> {
-        let Some(interp) = &self.i else {
+        let Some(vm) = &self.vm else {
             return vec![]
         };
-        interp.callstack.0.iter()
+        vm.callstack.0.iter()
             .map(|ip| ip.into())
             .collect()
     }
 
     pub fn ip(&self) -> ExportedInstructionPointer {
-        let Some(interp) = &self.i else {
+        let Some(vm) = &self.vm else {
             return ExportedInstructionPointer { word: 0, offset: 0 }
         };
-        (&interp.ip).into()
+        (&vm.ip).into()
     }
 
     pub fn reset_ip(&mut self) {
-        let Some(interp) = &mut self.i else {
+        let Some(vm) = &mut self.vm else {
             return;
         };
-        interp.ip.word = 0;
-        interp.ip.offset = 0;
+        vm.ip.word = 0;
+        vm.ip.offset = 0;
     }
 }
 
 #[wasm_bindgen]
-pub fn make_interp() -> ExportedInterp {
-    ExportedInterp::new()
+pub fn make_vm() -> ExportedVM {
+    ExportedVM::new()
 }
 
 #[wasm_bindgen(start)]