debug feature now works like a charm

Author: voidash

8085-wasm/src/lib.rs

@@ -75,24 +75,23 @@ impl Emulator {
     }
 
     pub fn assemble(&self,data: &str) -> Box<[u8]> {
-
-        let my_vec = generate_assembly_code(vec![String::from(data)]);
+        let (my_vec,_) = generate_assembly_code(vec![String::from(data)]);
         my_vec.into_boxed_slice()
     }
 
 
-    pub fn load_program(&mut self,offset:usize, data: Box<[JsValue]>) -> usize{
+    pub fn load_program(&mut self,offset:usize, data: Box<[JsValue]>) -> Box<[usize]>{
        let start_address = self.offset;
        let formatted_data = data.iter().map(|s| { s.as_string().unwrap().to_lowercase() }).collect();
 
-       let assembled_code = generate_assembly_code(formatted_data);
+       let (assembled_code,meta) = generate_assembly_code(formatted_data);
 
        let mut position = start_address+offset;
        for (counter,&hex_code) in assembled_code.iter().enumerate() {
            self.state.memory[start_address + offset + counter]  = hex_code;
            position = position + counter;
        } 
-       position
+       meta.into_boxed_slice()
     }
 
     pub fn watch_memory(&self, start: usize, stop : usize ) -> Box<[u8]> {

frontend/src/App.tsx

@@ -15,8 +15,8 @@ import * as wasm from './wasm/wasm_8085';
 type CodeEditor = monaco.editor.IStandaloneCodeEditor;
 
 function App() {
-  let [line, setLine] = useState<number>(0);
-  let [programCounter, setProgramCounter] = useState<number>(0);
+  let [line, setLine] = useState<number>(1);
+  let [pcLineVec, setPcLineVec] = useState<Uint32Array>(new Uint32Array());
   let [code, setCode]  = useState<string[]>([]);
   let [loaded, setLoaded]  = useState<boolean>(false);
   let [decoration, setDecoration] = useState<string[] | undefined>();
@@ -76,21 +76,28 @@ function App() {
   }
 
   function debugMode() {
-      setLoaded(!loaded);
-      gotoLine(line+1);
-      let newPC = emulator?.load_program(programCounter,[code[line]]) as number;
-      setProgramCounter(newPC);
-      console.log(newPC + "is new program counter");
-      setLine(line + 1);
+    if(loaded) {
+
+      emulator?.emulate_line_by_line();
+      let val = pcLineVec.findIndex((val) => {
+        return emulator?.program_counter() as number == val;
+      });
+
+      setLine(val+1);
+      gotoLine(line);
+
+      console.log(line);
       stopDecoration();
+    }
   }
 
   function loadProgram() {
-
     //force update
+    setLine(0)
     loadEmulator(() => {
       setEmulator(new wasm.Emulator(0));
-      emulator?.load_program(0,code);
+      setPcLineVec(emulator?.load_program(0,code) as Uint32Array);
+      console.log(pcLineVec);
       emulator?.set_program_counter(0);
       setLoaded(true);
     });

src/lib.rs

@@ -9,7 +9,6 @@ use assembler::utils::convert_8085_hex_to_i32;
 use assembler::assemble;
 use assembler::assembly;
 
-use crate::core::AssembledMeta;
 
 fn remove_comments(line: &str) -> &str{
     if let Some(index) = line.find(";") {
@@ -48,13 +47,13 @@ fn test_fix_hexadecimal() {
 
 
 #[allow(unused_variables,unused_mut)]
-pub fn generate_assembly_code(lines:Vec<String>) -> (Vec<u8>,Vec<AssembledMeta>) {
+pub fn generate_assembly_code(lines:Vec<String>) -> (Vec<u8>,Vec<usize>) {
 
     let mut label_offset_map: HashMap<String, u32> = HashMap::new();
 
 
     let mut assembly_code :Vec<u8> = Vec::new(); 
-    let mut assembled_metadata : Vec<AssembledMeta> = Vec::new();
+    let mut line_pc_vec: Vec<usize> = Vec::new();
     let mut line_number: u32 = 0;
 
     for line in lines {
@@ -65,26 +64,21 @@ pub fn generate_assembly_code(lines:Vec<String>) -> (Vec<u8>,Vec<AssembledMeta>)
        match assembly::OpcodeParser::new().parse(line) {
            Ok(ops) => {
                if let Some(l) = &ops.Label {
-                   label_offset_map.insert(l.clone(), line_number);
+                   label_offset_map.insert(l.clone(), assembly_code.len() as u32);
                }
-               let e_data = AssembledMeta {
-                   line_number : line_number as usize,
-                   start_position: assembly_code.len(),
-                   original_text : original_line 
-               };
                assembly_code.append(&mut assemble(ops, &label_offset_map));
-               assembled_metadata.push(e_data);
            },
             Err(_) => {println!("error");}
        }
+       line_pc_vec.push(assembly_code.len());
     }
-    (assembly_code,assembled_metadata)
+    (assembly_code,line_pc_vec)
 }
 
 
 #[test]
 fn test_if_assembly_generated() {
-    assert_eq!(generate_assembly_code(vec!["nop","trello: mvi c, 34H", "hello: mov b, c", "jz hello", "jnc trello"].iter().map(|&x| {String::from(x)}).collect()).0,vec![0, 14, 52, 65, 202, 3, 210, 2]);
+    assert_eq!(generate_assembly_code(vec!["nop","trello: mvi c, 34H", "hello: mov b, c", "jz hello", "jnc trello"].iter().map(|&x| {String::from(x)}).collect()).0,vec![0, 14, 52, 65, 202, 3, 210, 1]);
   assert_eq!(generate_assembly_code(vec!["mov a, b".to_string()]).0, vec![120]);
 }