replace function and comments with sdk api aligned alt

Author: rbran

src/id0/btree.rs

@@ -55,24 +55,27 @@ impl ID0Header {
         // NOTE before version V15, the string was at 0xd(13), after that
         // at 0x13(19). I think this is was a mistake on the developers part,
         // mixing the offset 13 with 0x13.
-        let version = if magic == IDBMagic::IDA0 {
-            let version = ID0Version::read(&mut &buf[0xd..0x27])
-                .ok_or_else(|| anyhow!("Unknown B-tree version"))?;
-            if version != ID0Version::V15 {
-                return Err(anyhow!(
-                    "Unexpected ID0 B-Tree Version header location"
-                ));
+        let version = match magic {
+            IDBMagic::IDA0 => {
+                let version = ID0Version::read(&mut &buf[0xd..0x27])
+                    .ok_or_else(|| anyhow!("Unknown B-tree version"))?;
+                if version != ID0Version::V15 {
+                    return Err(anyhow!(
+                        "Unexpected ID0 B-Tree Version header location"
+                    ));
+                }
+                version
             }
-            version
-        } else {
-            let version = ID0Version::read(&mut &buf[0x13..0x2d])
-                .ok_or_else(|| anyhow!("Unknown B-tree version"))?;
-            if version == ID0Version::V15 {
-                return Err(anyhow!(
-                    "Unexpected ID0 B-Tree Version header location"
-                ));
+            IDBMagic::IDA1 | IDBMagic::IDA2 => {
+                let version = ID0Version::read(&mut &buf[0x13..0x2d])
+                    .ok_or_else(|| anyhow!("Unknown B-tree version"))?;
+                if version == ID0Version::V15 {
+                    return Err(anyhow!(
+                        "Unexpected ID0 B-Tree Version header location"
+                    ));
+                }
+                version
             }
-            version
         };
 
         let mut buf_current = &buf[..];

src/id0/db.rs

@@ -9,8 +9,8 @@ use crate::addr_info::SubtypeId;
 use crate::id0::entry_iter::EntryTagContinuousFlat;
 use crate::id0::flag::nsup::NSUP_LLABEL;
 use crate::ida_reader::{IdbBufRead, IdbReadKind};
-use crate::SectionReader;
 use crate::{til, Address, IDBStr};
+use crate::{IDBString, SectionReader};
 
 use super::entry_iter::{
     EntryTagContinuousSubkeys, NetnodeRangeIter, NetnodeSupRangeIter,
@@ -1000,33 +1000,67 @@ impl<K: IDAKind> ID0Section<K> {
         funcs_idx(self)
     }
 
-    /// read the `$ funcs` entries of the database
-    pub fn functions_and_comments(
-        &self,
-        idx: FuncIdx<K>,
-    ) -> impl Iterator<Item = Result<FunctionsAndComments<'_, K>>> {
-        functions_and_comments(self, idx)
-    }
-
     pub fn fchunks(
         &self,
         idx: FuncIdx<K>,
     ) -> impl Iterator<Item = Result<IDBFunction<K>>> + use<'_, K> {
         fchunks(self, idx)
     }
 
-    pub fn function_containing_address(
+    fn cmt_inner(
         &self,
         idx: FuncIdx<K>,
-        ea: Address<K>,
-    ) -> Result<Option<IDBFunction<K>>> {
-        for fun in fchunks(self, idx) {
-            let fun = fun?;
-            if fun.address.contains(&ea) {
-                return Ok(Some(fun));
-            }
+        netdelta: Netdelta<K>,
+        addr: Address<K>,
+        tag: u8,
+    ) -> Result<Option<IDBString>> {
+        let Some(cmt) = self.sup_value(idx.into(), addr.into_raw(), tag) else {
+            return Ok(None);
+        };
+        // NOTE this is a u32
+        if !cmt.starts_with(&0x01020304u32.to_le_bytes()) {
+            return Ok(Some(IDBString(cmt.to_vec())));
         }
-        Ok(None)
+
+        let netnode = netdelta.ea2node(addr);
+        let Some(cmt) = self.sup_value(idx.into(), netnode.into_raw(), tag)
+        else {
+            return Ok(None);
+        };
+        // TODO is this u64 or usize?
+        // NOTE this is a u64
+        ensure!(
+            cmt.starts_with(&0x01020304u64.to_le_bytes()),
+            "Invalid cmt type 4321"
+        );
+        let Some(num) = cmt.get(8..16).and_then(K::usize_try_from_le_bytes)
+        else {
+            return Err(anyhow!("Invalid cmt type 4321 value"));
+        };
+
+        // TODO ignore if it is repeatable not not?
+        Ok(Some(IDBString(
+            self.blob(NetnodeIdx::from_raw(num), 0u8.into(), b'S')
+                .collect(),
+        )))
+    }
+
+    pub fn func_cmt(
+        &self,
+        idx: FuncIdx<K>,
+        netdelta: Netdelta<K>,
+        addr: Address<K>,
+    ) -> Result<Option<IDBString>> {
+        self.cmt_inner(idx, netdelta, addr, b'C')
+    }
+
+    pub fn func_repeatable_cmt(
+        &self,
+        idx: FuncIdx<K>,
+        netdelta: Netdelta<K>,
+        addr: Address<K>,
+    ) -> Result<Option<IDBString>> {
+        self.cmt_inner(idx, netdelta, addr, b'R')
     }
 
     // TODO implement $ fixups

src/id0/function.rs

@@ -55,14 +55,6 @@ pub(crate) fn funcs_idx<K: IDAKind>(
     Ok(id0.netnode_idx_by_name("$ funcs")?.map(|x| FuncIdx(x.0)))
 }
 
-pub(crate) fn functions_and_comments<K: IDAKind>(
-    id0: &ID0Section<K>,
-    idx: FuncIdx<K>,
-) -> impl Iterator<Item = Result<FunctionsAndComments<'_, K>>> {
-    id0.netnode_range(idx.into())
-        .map(move |(key, value)| FunctionsAndComments::read(key, value))
-}
-
 pub(crate) fn fchunks<K: IDAKind>(
     id0: &ID0Section<K>,
     idx: FuncIdx<K>,
@@ -112,68 +104,6 @@ pub struct IDBFunctionNonTail<K: IDAKind> {
     pub fpd: K::Usize,
 }
 
-#[derive(Clone, Debug, Serialize)]
-pub enum FunctionsAndComments<'a, K: IDAKind> {
-    // It's just the name "$ funcs"
-    Name,
-    Function(IDBFunction<K>),
-    Comment {
-        address: K::Usize,
-        comment: Comments<'a>,
-    },
-    Unknown {
-        key: &'a [u8],
-        value: &'a [u8],
-    },
-}
-
-impl<'a, K: IDAKind> FunctionsAndComments<'a, K> {
-    pub(crate) fn read(key: &'a [u8], value: &'a [u8]) -> Result<Self> {
-        let [key_type, sub_key @ ..] = key else {
-            return Err(anyhow!("invalid Funcs subkey"));
-        };
-        match *key_type {
-            flag::netnode::nn_res::NAME_TAG => {
-                ensure!(parse_maybe_cstr(value) == Some(&b"$ funcs"[..]));
-                Ok(Self::Name)
-            }
-            flag::netnode::nn_res::ARRAY_SUP_TAG => {
-                IDBFunction::read(value).map(Self::Function)
-            }
-            // some kind of style setting, maybe setting font and background color
-            b'R' | b'C' if value.starts_with(&[4, 3, 2, 1]) => {
-                Ok(Self::Unknown { key, value })
-            }
-            b'C' => {
-                let address = K::usize_try_from_be_bytes(sub_key)
-                    .ok_or_else(|| anyhow!("Invalid Comment address"))?;
-                parse_maybe_cstr(value)
-                    .map(|value| Self::Comment {
-                        address,
-                        comment: Comments::Comment(IDBStr::new(value)),
-                    })
-                    .ok_or_else(|| anyhow!("Invalid Comment string"))
-            }
-            b'R' => {
-                let address =
-                    K::usize_try_from_be_bytes(sub_key).ok_or_else(|| {
-                        anyhow!("Invalid Repetable Comment address")
-                    })?;
-                parse_maybe_cstr(value)
-                    .map(|value| Self::Comment {
-                        address,
-                        comment: Comments::RepeatableComment(IDBStr::new(
-                            value,
-                        )),
-                    })
-                    .ok_or_else(|| anyhow!("Invalid Repetable Comment string"))
-            }
-            // TODO find the meaning of "$ funcs" b'V' entries
-            _ => Ok(Self::Unknown { key, value }),
-        }
-    }
-}
-
 impl<K: IDAKind> IDBFunction<K> {
     // InnerRef 66961e377716596c17e2330a28c01eb3600be518 0x37dd30
     // InnerRef 5c1b89aa-5277-4c98-98f6-cec08e1946ec 0x28f810

src/sdk_comp/funcs.rs

@@ -3,18 +3,19 @@ use std::ops::Range;
 use crate::id0::function::{
     IDBFunctionNonTail, IDBFunctionTail, IDBFunctionType,
 };
-use crate::Address;
+use crate::id0::Netdelta;
 use crate::{id0::ID0Section, IDAKind};
+use crate::{Address, IDBString};
 
 use super::frame::{regvar_t, stkpnt_t};
 use super::nalt::type_t;
 use super::pro::{asize_t, bgcolor_t, ea_t, uval_t};
 use super::DataFetch;
 
-use anyhow::Result;
+use anyhow::{anyhow, Result};
 
 pub struct func_t<'a, K: IDAKind> {
-    pub range: Range<K::Usize>,
+    pub range: Range<Address<K>>,
     pub flags: u64,
     pub func_t_type: func_t_type<'a, K>,
 }
@@ -66,8 +67,7 @@ pub fn get_fchunk<'a, K: IDAKind>(
         let chunk = chunk?;
         if chunk.address.contains(&Address::from_raw(ea.0)) {
             return Ok(Some(func_t {
-                range: chunk.address.start.into_raw()
-                    ..chunk.address.end.into_raw(),
+                range: chunk.address,
                 flags: chunk.flags.into_raw(),
                 func_t_type: match chunk.extra {
                     IDBFunctionType::Tail(IDBFunctionTail {
@@ -129,3 +129,57 @@ pub fn get_func<'a, K: IDAKind>(
         Ok(Some(func))
     }
 }
+
+pub fn getn_func<'a, K: IDAKind>(
+    id0: &'a ID0Section<K>,
+    n: usize,
+) -> Result<Option<func_t<'a, K>>> {
+    // TODO how the old versions work?
+    let ords = id0
+        .funcords_idx()?
+        .ok_or_else(|| anyhow!("Missing funcords entry"))?;
+    let Some(addr) = id0.funcords(ords)?.skip(n).next() else {
+        return Ok(None);
+    };
+    get_func(id0, addr?)
+}
+
+pub fn get_func_num<'a, K: IDAKind>(
+    id0: &'a ID0Section<K>,
+    ea: ea_t<K>,
+) -> Result<Option<usize>> {
+    // TODO how the old versions work?
+    let ords = id0
+        .funcords_idx()?
+        .ok_or_else(|| anyhow!("Missing funcords entry"))?;
+    for (i, fun_addr) in id0.funcords(ords)?.enumerate() {
+        if fun_addr? == ea {
+            return Ok(Some(i));
+        }
+    }
+    Ok(None)
+}
+
+pub fn get_func_qty<'a, K: IDAKind>(id0: &'a ID0Section<K>) -> Result<usize> {
+    // TODO how the old versions work?
+    let ords = id0
+        .funcords_idx()?
+        .ok_or_else(|| anyhow!("Missing funcords entry"))?;
+    Ok(id0.funcords(ords)?.count())
+}
+
+pub fn get_func_cmt<'a, K: IDAKind>(
+    id0: &'a ID0Section<K>,
+    netdelta: Netdelta<K>,
+    addr: Address<K>,
+    repeatable: bool,
+) -> Result<Option<IDBString>> {
+    let func_idx = id0
+        .funcs_idx()?
+        .ok_or_else(|| anyhow!("Missing funcs entry"))?;
+    if repeatable {
+        id0.func_repeatable_cmt(func_idx, netdelta, addr)
+    } else {
+        id0.func_cmt(func_idx, netdelta, addr)
+    }
+}

src/tools/dump_dirtree_funcs.rs

@@ -44,9 +44,15 @@ pub fn print_function<K: IDAKind>(
     let root_info_idx = id0.root_node()?;
     let root_info = id0.ida_info(root_info_idx)?;
     let image_base = root_info.netdelta();
-    let info = AddressInfo::new(id0, id1, id2, image_base, address).unwrap();
-    let name = info.label()?;
-    let ty = info.tinfo()?;
+    let info = AddressInfo::new(id0, id1, id2, image_base, address);
+    let name = info
+        .as_ref()
+        .and_then(|info| info.label().transpose())
+        .transpose()?;
+    let ty = info
+        .as_ref()
+        .and_then(|info| info.tinfo().transpose())
+        .transpose()?;
 
     print!("{:#x}:", address.into_raw());
     match (name, ty) {