mapfile_parser 2.12.2__tar.gz → 2.13.0__tar.gz

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.13.0] - 2026-06-28
+
+### Added
+
+- `findPossibleSymbolsByVram`, `findPossibleSymbolsByVrom`, and
+  `findPossibleSymbolsByName` for `MapFile` and `findPossibleSymbolByVram`,
+  `findPossibleSymbolByVrom`, and `findPossibleSymbolsByName` for `Segment`.
+  - Allow iterating over the mapfile looking for multiple symbols that could
+    match either the vram, vrom or name given instead of stopping at the first
+    one that matches the criteria.
+- `Symbol::isNonmatching`: If true, the current symbol is a `.NON_MATCHING`
+  marker symbol.
+- `Section::containsVram`, `Section::containsVrom`, `Segment::containsVram`,
+  `Segment::containsVrom`.
+
+### Changed
+
+- `sym_info` now iterates over every possible vram/vrom address for every
+  segment instead of only printing the first found one.
+
 ## [2.12.2] - 2026-05-30
 
 ### Fixed
@@ -708,8 +728,9 @@ Full changes: <https://github.com/Decompollaborate/mapfile_parser/compare/702a73
 
 - Initial release
 
-[unreleased]: https://github.com/Decompollaborate/mapfile_parser/compare/2.12.2...HEAD
+[unreleased]: https://github.com/Decompollaborate/mapfile_parser/compare/2.13.0...HEAD
 
+[2.13.0]: https://github.com/Decompollaborate/mapfile_parser/compare/2.21.2...2.13.0
 [2.12.2]: https://github.com/Decompollaborate/mapfile_parser/compare/2.21.1...2.12.2
 [2.12.1]: https://github.com/Decompollaborate/mapfile_parser/compare/2.21.0...2.12.1
 [2.12.0]: https://github.com/Decompollaborate/mapfile_parser/compare/2.11.0...2.12.0

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/Cargo.lock

@@ -171,7 +171,7 @@ checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "mapfile_parser"
-version = "2.12.2"
+version = "2.13.0"
 dependencies = [
  "lazy_static",
  "objdiff-core",

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "mapfile_parser"
-version = "2.12.2"
+version = "2.13.0"
 edition = "2021"
 rust-version = "1.74.0"
 authors = ["Anghelo Carvajal <angheloalf95@gmail.com>"]

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapfile_parser
-Version: 2.12.2
+Version: 2.13.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -90,7 +90,7 @@ cargo add mapfile_parser
 Or add the following line manually to your `Cargo.toml` file:
 
 ```toml
-mapfile_parser = "2.12"
+mapfile_parser = "2.13"
 ```
 
 ## Versioning and changelog

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/README.md

@@ -75,7 +75,7 @@ cargo add mapfile_parser
 Or add the following line manually to your `Cargo.toml` file:
 
 ```toml
-mapfile_parser = "2.12"
+mapfile_parser = "2.13"
 ```
 
 ## Versioning and changelog

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/pyproject.toml

@@ -3,7 +3,7 @@
 
 [project]
 name = "mapfile_parser"
-version = "2.12.2"
+version = "2.13.0"
 description = "Map file parser library focusing decompilation projects"
 readme = "README.md"
 requires-python = ">=3.8"

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/src/mapfile_parser/__init__.py

@@ -5,7 +5,7 @@
 
 from __future__ import annotations
 
-__version_info__ = (2, 12, 2)
+__version_info__ = (2, 13, 0)
 __version__ = ".".join(map(str, __version_info__))  # + "-dev0"
 __author__ = "Decompollaborate"
 

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/src/mapfile_parser/frontends/sym_info.py

@@ -9,6 +9,7 @@ import argparse
 from collections.abc import Callable
 import decomp_settings
 from pathlib import Path
+from typing import Generator
 
 from .. import mapfile
 from .. import utils
@@ -31,36 +32,52 @@ def doSymInfo(
     if plfResolver is not None:
         mapFile = mapFile.resolvePartiallyLinkedFiles(plfResolver)
 
-    possibleFiles: list[mapfile.Section] = []
+    count = 0
+    for info in iterateSymbols(
+        mapFile,
+        symName,
+        as_vram,
+        as_vrom,
+        as_name,
+    ):
+        print(info.getAsStrPlusOffset(symName))
+        count += 1
+
+    if count == 0:
+        print(f"'{symName}' not found in map file '{mapPath}'")
+        return 1
+    return 0
+
 
+def iterateSymbols(
+    mapFile: mapfile.MapFile,
+    symName: str,
+    as_vram: bool,
+    as_vrom: bool,
+    as_name: bool,
+) -> Generator[mapfile.MaybeFoundSymbolInfo]:
     if as_vram:
         address = int(symName, 0)
-        info, possibleFiles = mapFile.findSymbolByVram(address)
+        for info in mapFile.findPossibleSymbolsByVram(address):
+            yield info
     elif as_vrom:
         address = int(symName, 0)
-        info, possibleFiles = mapFile.findSymbolByVrom(address)
+        for info in mapFile.findPossibleSymbolsByVrom(address):
+            yield info
     elif as_name:
-        info = mapFile.findSymbolByName(symName)
+        for info in mapFile.findPossibleSymbolsByName(symName):
+            yield info
 
     # Start the guessing game
     elif utils.convertibleToInt(symName, 0):
         address = int(symName, 0)
-        info, possibleFiles = mapFile.findSymbolByVram(address)
-        if info is None:
-            info, possibleFiles2 = mapFile.findSymbolByVrom(address)
-            possibleFiles.extend(possibleFiles2)
+        for info in mapFile.findPossibleSymbolsByVram(address):
+            yield info
+        for info in mapFile.findPossibleSymbolsByVrom(address):
+            yield info
     else:
-        info = mapFile.findSymbolByName(symName)
-
-    if info is not None:
-        print(info.getAsStrPlusOffset(symName))
-        return 0
-    print(f"'{symName}' not found in map file '{mapPath}'")
-    if len(possibleFiles) > 0:
-        print("But it may be a local symbol of either of the following files:")
-        for f in possibleFiles:
-            print(f"    {f.asStr()})")
-    return 1
+        for info in mapFile.findPossibleSymbolsByName(symName):
+            yield info
 
 
 def processArguments(

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/src/mapfile_parser/mapfile.py

@@ -40,10 +40,10 @@ class FoundSymbolInfo:
     symbol: Symbol
     offset: int = 0
 
-    def getAsStr(self) -> str:
-        return f"'{self.symbol.name}' (VRAM: {self.symbol.getVramStr()}, VROM: {self.symbol.getVromStr()}, SIZE: {self.symbol.getSizeStr()}, {self.section.filepath})"
+    def getAsStr(self, *, extra: str = "") -> str:
+        return f"'{self.symbol.name}' (VRAM: {self.symbol.getVramStr()}, VROM: {self.symbol.getVromStr()}, SIZE: {self.symbol.getSizeStr()}, {self.section.filepath}{extra})"
 
-    def getAsStrPlusOffset(self, symName: str | None = None) -> str:
+    def getAsStrPlusOffset(self, symName: str | None = None, *, extra: str = "") -> str:
         if self.offset != 0:
             if symName is not None:
                 message = symName
@@ -52,7 +52,29 @@ class FoundSymbolInfo:
             message += f" is at 0x{self.offset:X} bytes inside"
         else:
             message = "Symbol"
-        return f"{message} {self.getAsStr()}"
+        return f"{message} {self.getAsStr(extra=extra)}"
+
+
+@dataclasses.dataclass
+class MaybeFoundSymbolInfo:
+    segment: Segment
+    section: Section
+    symbol: Symbol | None
+    offset: int
+
+    def getAsStrPlusOffset(self, symName: str) -> str:
+        if self.symbol is not None:
+            info = FoundSymbolInfo(
+                self.section,
+                self.symbol,
+                self.offset,
+            )
+            return info.getAsStrPlusOffset(symName, extra=f", SEG: {self.segment.name}")
+
+        extra = ""
+        if self.offset != 0:
+            extra = f" at offset 0x{self.offset:X}"
+        return f"{symName} may be part of section {self.section.filepath} (segment {self.segment.name}){extra}, but it isn't globally visible."
 
 
 @dataclasses.dataclass
@@ -107,6 +129,12 @@ class Symbol:
     Note the symbol with the actual `.NON_MATCHING` will have this member
     set to `false`.
     """
+    isNonmatching: bool = False
+    """
+    `true` if this symbol has a `.NON_MATCHING` suffix.
+
+    Note `.NON_MATCHING` marker symbols have size 0.
+    """
     inferredStatic: bool = False
 
     def getVramStr(self) -> str:
@@ -173,6 +201,7 @@ class Symbol:
             self.vrom,
             self.align,
             self.nonmatchingSymExists,
+            self.isNonmatching,
             self.inferredStatic,
         )
 
@@ -201,6 +230,14 @@ class Section:
     def isNoloadSection(self) -> bool:
         return self.sectionType in {".bss", ".sbss", "COMMON", ".scommon"}
 
+    def containsVram(self, address: int) -> bool:
+        return address >= self.vram and address < self.vram + self.size
+
+    def containsVrom(self, address: int) -> bool | None:
+        if self.vrom is None:
+            return None
+        return address >= self.vrom and address < self.vrom + self.size
+
     def serializeVram(self, humanReadable: bool = True) -> str | int | None:
         if humanReadable:
             return f"0x{self.vram:08X}"
@@ -281,60 +318,76 @@ class Section:
         return None
 
     def findSymbolByVram(self, address: int) -> tuple[Symbol, int] | None:
-        prevSym: Symbol | None = None
+        nonMatchingSym: Symbol | None = None
 
         for sym in self._symbols:
             if sym.vram == address:
+                # Matching address
+                if sym.isNonmatching:
+                    # Try to avoid non matching marker symbols
+                    nonMatchingSym = sym
+                    continue
                 return sym, 0
 
-            if prevSym is not None:
-                if sym.vram > address:
-                    offset = address - prevSym.vram
-                    if offset < 0:
-                        return None
-                    return prevSym, offset
+            if sym.vram > address:
+                # We somehow go through the symbol without seeing it?
+                break
 
-            prevSym = sym
+            if sym.size == 0:
+                # The only way for a symbol to have size zero is to be a
+                # nonmatching marker, usually at least.
+                if sym.isNonmatching:
+                    # Try to avoid non matching marker symbols
+                    nonMatchingSym = sym
+                continue
 
-        if prevSym is not None:
-            if prevSym.size is not None and prevSym.vram + prevSym.size > address:
-                offset = address - prevSym.vram
-                if offset < 0:
-                    return None
-                return prevSym, offset
+            if sym.vram < address and address < sym.vram + sym.size:
+                if sym.isNonmatching:
+                    # Try to avoid non matching marker symbols
+                    nonMatchingSym = sym
+                    continue
+                return sym, address - sym.vram
 
+        if nonMatchingSym is not None:
+            return nonMatchingSym, address - nonMatchingSym.vram
         return None
 
     def findSymbolByVrom(self, address: int) -> tuple[Symbol, int] | None:
-        prevVrom = self.vrom if self.vrom is not None else 0
-        prevSym: Symbol | None = None
+        nonMatchingSym: Symbol | None = None
 
         for sym in self._symbols:
+            if sym.vrom is None:
+                continue
+
             if sym.vrom == address:
+                # Matching address
+                if sym.isNonmatching:
+                    # Try to avoid non matching marker symbols
+                    nonMatchingSym = sym
+                    continue
                 return sym, 0
 
-            if prevSym is not None:
-                if sym.vrom is not None and sym.vrom > address:
-                    offset = address - prevVrom
-                    if offset < 0:
-                        return None
-                    return prevSym, offset
+            if sym.vrom > address:
+                # We somehow go through the symbol without seeing it?
+                break
 
-            if sym.vrom is not None:
-                prevVrom = sym.vrom
-            prevSym = sym
+            if sym.size == 0:
+                # The only way for a symbol to have size zero is to be a
+                # nonmatching marker, usually at least.
+                if sym.isNonmatching:
+                    # Try to avoid non matching marker symbols
+                    nonMatchingSym = sym
+                continue
 
-        if prevSym is not None:
-            if (
-                prevSym.vrom is not None
-                and prevSym.size is not None
-                and prevSym.vrom + prevSym.size > address
-            ):
-                offset = address - prevVrom
-                if offset < 0:
-                    return None
-                return prevSym, offset
+            if sym.vrom < address and address < sym.vrom + sym.size:
+                if sym.isNonmatching:
+                    # Try to avoid non matching marker symbols
+                    nonMatchingSym = sym
+                    continue
+                return sym, address - sym.vrom
 
+        if nonMatchingSym is not None and nonMatchingSym.vrom is not None:
+            return nonMatchingSym, address - nonMatchingSym.vrom
         return None
 
     @staticmethod
@@ -444,6 +497,14 @@ class Segment:
     align: int | None = None
     _sectionsList: list[Section] = dataclasses.field(default_factory=list)
 
+    def containsVram(self, address: int) -> bool:
+        return address >= self.vram and address < self.vram + self.size
+
+    def containsVrom(self, address: int) -> bool | None:
+        if self.vrom is None:
+            return None
+        return address >= self.vrom and address < self.vrom + self.size
+
     def serializeVram(self, humanReadable: bool = True) -> str | int | None:
         if humanReadable:
             return f"0x{self.vram:08X}"
@@ -498,7 +559,8 @@ class Segment:
         return None
 
     def findSymbolByVram(
-        self, address: int
+        self,
+        address: int,
     ) -> tuple[FoundSymbolInfo | None, list[Section]]:
         possibleFiles: list[Section] = []
         for section in self._sectionsList:
@@ -506,12 +568,13 @@ class Segment:
             if pair is not None:
                 sym, offset = pair
                 return FoundSymbolInfo(section, sym, offset), []
-            if address >= section.vram and address < section.vram + section.size:
+            if section.containsVram(address):
                 possibleFiles.append(section)
         return None, possibleFiles
 
     def findSymbolByVrom(
-        self, address: int
+        self,
+        address: int,
     ) -> tuple[FoundSymbolInfo | None, list[Section]]:
         possibleFiles: list[Section] = []
         for section in self._sectionsList:
@@ -521,10 +584,51 @@ class Segment:
             if pair is not None:
                 sym, offset = pair
                 return FoundSymbolInfo(section, sym, offset), []
-            if address >= section.vrom and address < section.vrom + section.size:
+            if section.containsVrom(address):
                 possibleFiles.append(section)
         return None, possibleFiles
 
+    def findPossibleSymbolByVram(
+        self,
+        address: int,
+    ) -> MaybeFoundSymbolInfo | None:
+        for section in self._sectionsList:
+            if section.containsVram(address):
+                pair = section.findSymbolByVram(address)
+                if pair is not None:
+                    sym, offset = pair
+                else:
+                    sym = None
+                    offset = address - section.vram
+                return MaybeFoundSymbolInfo(self, section, sym, offset)
+        return None
+
+    def findPossibleSymbolByVrom(
+        self,
+        address: int,
+    ) -> MaybeFoundSymbolInfo | None:
+        for section in self._sectionsList:
+            if section.vrom is not None and section.containsVrom(address):
+                pair = section.findSymbolByVrom(address)
+                if pair is not None:
+                    sym, offset = pair
+                else:
+                    sym = None
+                    offset = address - section.vram
+                return MaybeFoundSymbolInfo(self, section, sym, offset)
+        return None
+
+    def findPossibleSymbolsByName(
+        self,
+        symName: str,
+    ) -> Generator[MaybeFoundSymbolInfo]:
+        # There may be multiple symbols with the same name in the same segment,
+        # so this function iterate over them and yields them all.
+        for section in self._sectionsList:
+            sym = section.findSymbolByName(symName)
+            if sym is not None:
+                yield MaybeFoundSymbolInfo(self, section, sym, 0)
+
     def mixFolders(self) -> Segment:
         newSegment = Segment(self.name, self.vram, self.size, self.vrom)
 
@@ -735,6 +839,7 @@ class MapFile:
                         symbol.vrom,
                         symbol.align,
                         symbol.nonmatchingSymExists,
+                        symbol.isNonmatching,
                         symbol.inferredStatic,
                     )
 
@@ -768,6 +873,7 @@ class MapFile:
                         symbol.vrom,
                         symbol.align,
                         symbol.nonmatchingSymExists,
+                        symbol.isNonmatching,
                         symbol.inferredStatic,
                     )
 
@@ -914,6 +1020,32 @@ class MapFile:
             possibleFiles.extend(possibleFilesAux)
         return None, possibleFiles
 
+    def findPossibleSymbolsByVram(
+        self,
+        address: int,
+    ) -> Generator[MaybeFoundSymbolInfo]:
+        for segment in self._segmentsList:
+            info = segment.findPossibleSymbolByVram(address)
+            if info is not None:
+                yield info
+
+    def findPossibleSymbolsByVrom(
+        self,
+        address: int,
+    ) -> Generator[MaybeFoundSymbolInfo]:
+        for segment in self._segmentsList:
+            info = segment.findPossibleSymbolByVrom(address)
+            if info is not None:
+                yield info
+
+    def findPossibleSymbolsByName(
+        self,
+        symName: str,
+    ) -> Generator[MaybeFoundSymbolInfo]:
+        for segment in self._segmentsList:
+            for info in segment.findPossibleSymbolsByName(symName):
+                yield info
+
     def findLowestDifferingSymbol(
         self, otherMapFile: MapFile
     ) -> tuple[Symbol, Section, Symbol | None] | None:

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/src/mapfile_parser/mapfile_parser.pyi

@@ -71,6 +71,7 @@ class Symbol:
     vrom: int | None
     align: int | None
     nonmatchingSymExists: bool
+    isNonmatching: bool
     inferredStatic: bool
 
     def __init__(
@@ -81,6 +82,7 @@ class Symbol:
         vrom: int | None = None,
         align: int | None = None,
         nonmatchingSymExists: bool = False,
+        isNonmatching: bool = False,
         inferredStatic: bool = False,
     ): ...
     def getVramStr(self) -> str: ...
@@ -123,6 +125,8 @@ class Section:
     ) -> None: ...
     @property
     def isNoloadSection(self) -> bool: ...
+    def containsVram(self, address: int) -> bool: ...
+    def containsVrom(self, address: int) -> bool | None: ...
     def serializeVram(self, humanReadable: bool = True) -> str | int | None: ...
     def serializeSize(self, humanReadable: bool = True) -> str | int | None: ...
     def serializeVrom(self, humanReadable: bool = True) -> str | int | None: ...
@@ -172,6 +176,8 @@ class Segment:
         vrom: int | None,
         align: int | None = None,
     ): ...
+    def containsVram(self, address: int) -> bool: ...
+    def containsVrom(self, address: int) -> bool | None: ...
     def serializeVram(self, humanReadable: bool = True) -> str | int | None: ...
     def serializeSize(self, humanReadable: bool = True) -> str | int | None: ...
     def serializeVrom(self, humanReadable: bool = True) -> str | int | None: ...

{mapfile_parser-2.12.2 → mapfile_parser-2.13.0}/src/rs/found_symbol_info.rs

@@ -1,7 +1,7 @@
 /* SPDX-FileCopyrightText: © 2023-2025 Decompollaborate */
 /* SPDX-License-Identifier: MIT */
 
-use std::fmt::Write;
+use std::borrow::Cow;
 
 use crate::{section, symbol};
 
@@ -32,31 +32,43 @@ impl<'a> FoundSymbolInfo<'a> {
     }
 
     pub fn get_as_str(&self) -> String {
-        format!(
-            "'{0}' (VRAM: {1}, VROM: {2}, SIZE: {3}, {4})",
-            self.symbol.name,
-            self.symbol.get_vram_str(),
-            self.symbol.get_vrom_str(),
-            self.symbol.get_size_str(),
-            self.section.filepath.to_string_lossy()
-        )
+        self.get_as_str_impl(Cow::from(""))
+    }
+
+    pub(crate) fn get_as_str_impl(&self, extra: Cow<'_, str>) -> String {
+        let name = &self.symbol.name;
+        let vram = self.symbol.get_vram_str();
+        let vrom = self.symbol.get_vrom_str();
+        let size = self.symbol.get_size_str();
+        let section_path = self.section.filepath.to_string_lossy();
+
+        format!("'{name}' (VRAM: {vram}, VROM: {vrom}, SIZE: {size}, {section_path}{extra})")
     }
 
     pub fn get_as_str_plus_offset(&self, sym_name: Option<String>) -> String {
-        let mut message;
+        self.get_as_str_plus_offset_impl(sym_name.map(Cow::from), Cow::from(""))
+    }
 
-        if self.offset != 0 {
-            if let Some(name) = sym_name {
-                message = name;
-            } else {
-                message = format!("0x{0:X}", self.symbol.vram as i64 + self.offset);
-            }
-            write!(message, " is at 0x{0:X} bytes inside", self.offset).unwrap();
+    pub(crate) fn get_as_str_plus_offset_impl(
+        &self,
+        sym_name: Option<Cow<'_, str>>,
+        extra: Cow<'_, str>,
+    ) -> String {
+        let message = if self.offset == 0 {
+            Cow::from("Symbol")
         } else {
-            message = "Symbol".to_string();
-        }
-
-        format!("{0} {1}", message, self.get_as_str())
+            let mes = if let Some(name) = sym_name {
+                name
+            } else {
+                Cow::from(format!(
+                    "0x{0:X}",
+                    self.symbol.vram.wrapping_add_signed(self.offset)
+                ))
+            };
+            Cow::from(format!("{} is at 0x{:X} bytes inside", mes, self.offset))
+        };
+
+        format!("{0} {1}", message, self.get_as_str_impl(extra))
     }
 }