stop false alarm of regbank, favor lab over equ, reorg commands

src/db/debugdb.rs

@@ -49,7 +49,18 @@ impl DebugData {
         ret.create_tables()?;
         Ok(ret)
     }
-
+    fn convert_symbol_type(s: &str) -> SymbolType {
+        match s {
+            "lab" => SymbolType::Label,
+            "equ" => SymbolType::Equate,
+            "c" => SymbolType::CSymbol,
+            _ => {
+                //  unreachable!("unknown symbol type");
+                //  bail!("unknown symbol type");
+                SymbolType::Unknown
+            } //SymbolType::Unknown,
+        }
+    }
     pub fn get_symbols(&self, filter: Option<&String>) -> Result<Vec<Symbol>> {
         let mut v = Vec::new();
         let mut stmt = self
@@ -59,15 +70,7 @@ impl DebugData {
             let name = row.get::<usize, String>(0)?;
             let val = row.get::<usize, i64>(1)? as u16;
             let module = row.get::<usize, Option<String>>(2)?;
-            let sym_type = match row.get::<usize, String>(3)?.as_str() {
-                "lab" => SymbolType::Label,
-                "equ" => SymbolType::Equate,
-                _ => {
-                    //  unreachable!("unknown symbol type");
-                    //  bail!("unknown symbol type");
-                    SymbolType::Unknown
-                } //SymbolType::Unknown,
-            };
+            let sym_type = Self::convert_symbol_type(row.get::<usize, String>(3)?.as_str());
 
             Ok((name, val, module, sym_type))
         })?;
@@ -132,9 +135,14 @@ impl DebugData {
         let rows = stmt.query_map([name], |row| {
             let name = row.get::<usize, String>(0)?;
             let val = row.get::<usize, i64>(1)? as u16;
-            let mut module = row.get::<usize, String>(2)?;
-            module = module.strip_suffix(".o").unwrap_or(&module).to_string();
-            Ok((name, val, module))
+            let module = row.get::<usize, Option<String>>(2)?;
+            let m = if let Some(m) = module {
+                m.strip_suffix(".o").unwrap_or(&m).to_string()
+            } else {
+                String::new()
+            };
+
+            Ok((name, val, m))
         })?;
         for row in rows {
             let (name, val, m) = row?;
@@ -169,18 +177,28 @@ impl DebugData {
         Ok(())
     }
 
-    pub fn find_symbol(&self, addr: u16) -> Result<Option<String>> {
+    pub fn find_symbol_by_addr(&self, addr: u16) -> Result<Vec<Symbol>> {
         let ans = self.query_db(
             params![addr],
-            "select symdef.name from symdef where symdef.val = ?1 and seg not null",
+            "select name, scope,type,val,seg from symdef where symdef.val = ?1 and seg not null",
         )?;
-
+        let mut v = Vec::new();
         for row in ans {
-            if let SqlValue::Text(s) = &row[0] {
-                return Ok(Some(s.to_string()));
-            }
+            let name = row[0].vto_string()?;
+            // let addr = row[1].vto_i64()?;
+            //  let module = row[2].vto_string()?;
+            let scope = row[1].vto_i64()?;
+            let type_ = row[2].vto_string()?;
+            let val = row[3].vto_i64()? as u16;
+            let seg = row[4].vto_i64()? as u8;
+            v.push(Symbol {
+                name,
+                value: val,
+                module: String::new(),
+                sym_type: Self::convert_symbol_type(&type_),
+            });
         }
-        Ok(None)
+        Ok(v)
     }
 
     pub fn load_all_cfiles(&mut self) -> Result<()> {

src/db/parsedb.rs

@@ -346,24 +346,6 @@ impl DebugData {
                 "auto" => {}
                 "reg" => {}
                 "static" => {
-                    // insert static as aliases for their assembly name
-                    // id integer primary key,
-                    // name text not null ,
-                    // addrsize text,
-                    //    scope integer,
-                    //    def integer,
-                    //    type text,
-                    //    exp integer,
-                    //    val integer,
-                    //    seg integer,
-                    //     size integer,
-                    //     parent integer,
-                    // symcount += 1;
-                    // let sql = "insert into symdef (id,name, scope, def, type, exp, val, seg, size, parent, addrsize) values (?1,?2,?3,?4,?5,?6,?7,?8,?9, ?10,?11)";
-                    // tx.execute(
-                    //     sql,
-                    //     params![symcount, name, scope, sym, type_, 0, 0, 0, 0, 0, "static"],
-                    // )?;
                     let row = self
                         .conn
                         .prepare_cached("select val,size,def from symdef where id = ?1")?
@@ -385,7 +367,7 @@ impl DebugData {
             let sql = "insert into symdef (id,name, scope, def, type, exp, val, seg, size, parent, addrsize) values (?1,?2,?3,?4,?5,?6,?7,?8,?9, ?10,?11)";
             tx.execute(
                 sql,
-                params![symcount, st.3, st.4, st.2, st.5, 0, st.0, 0, st.1, 0, "static"],
+                params![symcount, st.3, st.4, st.2, "c", 0, st.0, 0, st.1, 0, "static"],
             )?;
         }
         tx.commit()?;

src/debugger/debugger.rs

@@ -55,6 +55,7 @@ pub struct CodeLocation {
     pub absaddr: u16,
     pub scope: Option<i64>,
 }
+#[derive(Debug, Clone, Eq, PartialEq)]
 pub enum SymbolType {
     Unknown,
     Equate,
@@ -91,6 +92,8 @@ pub struct Debugger {
     pub(crate) privileged_mode: bool,
     pub(crate) debug_mode: DebugMode,
     pub(crate) file_table: HashMap<i64, SourceFile>,
+    pub(crate) regbank_addr: Option<u16>,
+    pub(crate) regbank_size: Option<u16>,
 }
 
 pub struct HeapBlock {
@@ -183,6 +186,8 @@ impl Debugger {
             privileged_mode: false,
             debug_mode: DebugMode::Unknown,
             file_table: HashMap::new(),
+            regbank_addr: None,
+            regbank_size: None,
         }
     }
     pub fn delete_breakpoint(&mut self, id_opt: Option<&String>) -> Result<()> {
@@ -313,12 +318,23 @@ impl Debugger {
         self.load_intercepts()?;
         self.init_shadow()?;
         self.dbgdb.load_files(&mut self.file_table)?;
+
+        // load file lines int expr db
         for (x, si) in self.source_info.iter() {
             if let Some(name) = self.lookup_file_by_id(si.file_id) {
                 let str = format!("{}:{}", name.short_name, si.line_no);
                 self.expr_context.symbols.insert(str, Value::Int(*x as i64));
             }
         }
+        let regbank = self.dbgdb.get_symbol("zeropage.regbank")?;
+        if regbank.len() != 0 {
+            self.regbank_addr = Some(regbank[0].1);
+        }
+        let regbanksize = self.dbgdb.get_symbol("regbanksize")?;
+        if regbanksize.len() != 0 {
+            self.regbank_size = Some(regbanksize[0].1);
+        }
+
         Ok(())
     }
     pub fn load_source(&mut self, file: &Path) -> Result<()> {
@@ -480,15 +496,25 @@ impl Debugger {
     // reverse of convert_addr.
     // tried to find a symbol matching an address
     // if not found it returns a numberic string
+    // prefernece is for a label
     pub fn symbol_lookup(&self, addr: u16) -> Result<String> {
-        if let Some(sym) = self.dbgdb.find_symbol(addr)? {
-            return Ok(sym);
+        let syms = self.dbgdb.find_symbol_by_addr(addr)?;
+        if let Some(sym) = syms.iter().find(|s| s.sym_type == SymbolType::Label) {
+            return Ok(sym.name.clone());
+        }
+        if syms.len() > 0 {
+            return Ok(syms[0].name.clone());
         }
         Ok(format!("${:04x}", addr))
     }
+    // same for zero page
     pub fn zp_symbol_lookup(&self, addr: u8) -> Result<String> {
-        if let Some(sym) = self.dbgdb.find_symbol(addr as u16)? {
-            return Ok(sym);
+        let syms = self.dbgdb.find_symbol_by_addr(addr as u16)?;
+        if let Some(sym) = syms.iter().find(|s| s.sym_type == SymbolType::Label) {
+            return Ok(sym.name.clone());
+        }
+        if syms.len() > 0 {
+            return Ok(syms[0].name.clone());
         }
 
         Ok(format!("${:02x}", addr))
@@ -683,9 +709,8 @@ impl Debugger {
                         return Ok(Some((sp65 as i64 + csym.value) as u16));
                     }
                     "reg" => {
-                        let regbank = self.dbgdb.get_symbol("zeropage.regbank")?;
-                        if regbank.len() == 1 {
-                            return Ok(Some((regbank[0].1 as i64 + csym.value) as u16));
+                        if let Some(regbank) = self.regbank_addr {
+                            return Ok(Some((regbank as i64 + csym.value) as u16));
                         }
                     }
                     "static" => {}

src/debugger/execute.rs

@@ -178,7 +178,17 @@ impl Debugger {
                 match Cpu::get_memcheck() {
                     MemCheck::None => {}
                     MemCheck::ReadNoWrite(addr) => {
-                        break 'main_loop StopReason::Bug(BugType::Memcheck(*addr));
+                        if let Some(regbank) = self.regbank_addr {
+                            if *addr >= regbank
+                                && *addr < (regbank + self.regbank_size.unwrap_or(6))
+                            {
+                                // OK
+                            } else {
+                                break 'main_loop StopReason::Bug(BugType::Memcheck(*addr));
+                            }
+                        } else {
+                            break 'main_loop StopReason::Bug(BugType::Memcheck(*addr));
+                        }
                     }
                     MemCheck::WriteNoPermission(addr) => {
                         break 'main_loop StopReason::Bug(BugType::SegCheck(*addr));

src/shell.rs

@@ -183,7 +183,7 @@ impl Shell {
                 return Ok(true);
             }
 
-            Some(("memory", args)) => {
+            Some(("display_memory", args)) => {
                 let addr_str = args.get_one::<String>("address").unwrap();
                 let addr_str = &self.expand_expr(addr_str)?;
                 let (addr, _) = self.debugger.convert_addr(addr_str)?;
@@ -298,7 +298,7 @@ impl Shell {
                 let (addr, _) = self.debugger.convert_addr(&addr_str)?;
                 self.print(addr, args)?;
             }
-            Some(("enable", args)) => {
+            Some(("enable_checks", args)) => {
                 self.debugger
                     .enable_mem_check(*args.get_one::<bool>("memcheck").unwrap());
                 self.debugger