mapfile-parser 2.9.4__cp310-cp310-win_amd64.whl → 2.11.0__cp310-cp310-win_amd64.whl

mapfile_parser/__init__.py

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

mapfile_parser/frontends/bss_check.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import argparse
+from collections.abc import Callable
 import decomp_settings
 from pathlib import Path
 
@@ -13,14 +14,23 @@ from .. import mapfile
 from .. import utils
 
 
-def getComparison(mapPath, expectedMapPath, *, reverseCheck: bool=True) -> mapfile.MapsComparisonInfo:
-    buildMap = mapfile.MapFile()
-    buildMap.readMapFile(mapPath)
+def getComparison(
+        mapPath: Path,
+        expectedMapPath: Path,
+        *,
+        reverseCheck: bool=True,
+        plfResolver: Callable[[Path], Path|None]|None=None,
+        plfResolverExpected: Callable[[Path], Path|None]|None=None,
+    ) -> mapfile.MapsComparisonInfo:
+    buildMap = mapfile.MapFile.newFromMapFile(mapPath)
     buildMap = buildMap.filterBySectionType(".bss")
+    if plfResolver is not None:
+        buildMap = buildMap.resolvePartiallyLinkedFiles(plfResolver)
 
-    expectedMap = mapfile.MapFile()
-    expectedMap.readMapFile(expectedMapPath)
+    expectedMap = mapfile.MapFile.newFromMapFile(expectedMapPath)
     expectedMap = expectedMap.filterBySectionType(".bss")
+    if plfResolverExpected is not None:
+        expectedMap = expectedMap.resolvePartiallyLinkedFiles(plfResolverExpected)
 
     return buildMap.compareFilesAndSymbols(expectedMap, checkOtherOnSelf=reverseCheck)
 
@@ -126,7 +136,15 @@ def printFileComparison(comparisonInfo: mapfile.MapsComparisonInfo):
         utils.eprint("Some files appear to be missing symbols. Have they been renamed or declared as static? You may need to remake 'expected'")
 
 
-def doBssCheck(mapPath, expectedMapPath, *, printAll: bool=False, reverseCheck: bool=True) -> int:
+def doBssCheck(
+        mapPath: Path,
+        expectedMapPath: Path,
+        *,
+        printAll: bool=False,
+        reverseCheck: bool=True,
+        plfResolver: Callable[[Path], Path|None]|None=None,
+        plfResolverExpected: Callable[[Path], Path|None]|None=None,
+    ) -> int:
     if not mapPath.exists():
         utils.eprint(f"{mapPath} must exist")
         return 1
@@ -134,7 +152,7 @@ def doBssCheck(mapPath, expectedMapPath, *, printAll: bool=False, reverseCheck:
         utils.eprint(f"{expectedMapPath} must exist")
         return 1
 
-    comparisonInfo = getComparison(mapPath, expectedMapPath, reverseCheck=reverseCheck)
+    comparisonInfo = getComparison(mapPath, expectedMapPath, reverseCheck=reverseCheck, plfResolver=plfResolver, plfResolverExpected=plfResolverExpected)
     printSymbolComparison(comparisonInfo, printAll)
 
     if len(comparisonInfo.badFiles) + len(comparisonInfo.missingFiles) != 0:
@@ -165,8 +183,20 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
 
     printAll: bool = args.print_all
     reverseCheck: bool = not args.no_reverse_check
+    plfExt: list[str]|None = args.plf_ext
 
-    exit(doBssCheck(mapPath, expectedMapPath, printAll=printAll, reverseCheck=reverseCheck))
+    plfResolver = None
+    if plfExt is not None:
+        def resolver(x: Path) -> Path|None:
+            if x.suffix in plfExt:
+                newPath = x.with_suffix(".map")
+                if newPath.exists():
+                    return newPath
+            return None
+
+        plfResolver = resolver
+
+    exit(doBssCheck(mapPath, expectedMapPath, printAll=printAll, reverseCheck=reverseCheck, plfResolver=plfResolver))
 
 
 def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser], decompConfig: decomp_settings.Config|None=None):
@@ -193,4 +223,6 @@ def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser],
     parser.add_argument("-a", "--print-all", help="Print all bss, not just non-matching.", action="store_true")
     parser.add_argument("--no-reverse-check", help="Disable looking for symbols on the expected map that are missing on the built map file.", action="store_true")
 
+    parser.add_argument("-x", "--plf-ext", help="File extension for partially linked files (plf). Will be used to transform the `plf`s path into a mapfile path by replacing the extension. The extension must contain the leading period. This argument can be passed multiple times.", action="append")
+
     parser.set_defaults(func=processArguments)

mapfile_parser/frontends/first_diff.py

@@ -6,15 +6,28 @@
 from __future__ import annotations
 
 import argparse
+from collections.abc import Callable
 import decomp_settings
 from pathlib import Path
-from typing import Callable, Literal
+from typing import Literal
 
 from .. import mapfile
 from .. import utils
 
 
-def doFirstDiff(mapPath, expectedMapPath, romPath, expectedRomPath, diffCount: int=5, mismatchSize: bool=False, addColons: bool=True, bytesConverterCallback:Callable[[bytes, mapfile.MapFile],str|None]|None=None, endian: Literal["big", "little"] ="big") -> int:
+def doFirstDiff(
+        mapPath: Path,
+        expectedMapPath: Path,
+        romPath: Path,
+        expectedRomPath: Path,
+        diffCount: int=5,
+        mismatchSize: bool=False,
+        addColons: bool=True,
+        bytesConverterCallback: Callable[[bytes, mapfile.MapFile],str|None]|None=None,
+        endian: Literal["big", "little"] ="big",
+        plfResolver: Callable[[Path], Path|None]|None=None,
+        plfResolverExpected: Callable[[Path], Path|None]|None=None,
+    ) -> int:
     if not mapPath.exists():
         print(f"{mapPath} must exist")
         return 1
@@ -41,10 +54,13 @@ def doFirstDiff(mapPath, expectedMapPath, romPath, expectedRomPath, diffCount: i
         print("No differences!")
         return 0
 
-    builtMapFile = mapfile.MapFile()
-    builtMapFile.readMapFile(mapPath)
-    expectedMapFile = mapfile.MapFile()
-    expectedMapFile.readMapFile(expectedMapPath)
+    builtMapFile = mapfile.MapFile.newFromMapFile(mapPath)
+    if plfResolver is not None:
+        builtMapFile = builtMapFile.resolvePartiallyLinkedFiles(plfResolver)
+
+    expectedMapFile = mapfile.MapFile.newFromMapFile(expectedMapPath)
+    if plfResolverExpected is not None:
+        expectedMapFile = expectedMapFile.resolvePartiallyLinkedFiles(plfResolverExpected)
 
     endian_diff = 0
     if endian == "little":
@@ -166,7 +182,20 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
 
     endian = args.endian
 
-    exit(doFirstDiff(mapPath, expectedMapPath, romPath, expectedRomPath, diffCount, mismatchSize, endian=endian))
+    plfExt: list[str]|None = args.plf_ext
+
+    plfResolver = None
+    if plfExt is not None:
+        def resolver(x: Path) -> Path|None:
+            if x.suffix in plfExt:
+                newPath = x.with_suffix(".map")
+                if newPath.exists():
+                    return newPath
+            return None
+
+        plfResolver = resolver
+
+    exit(doFirstDiff(mapPath, expectedMapPath, romPath, expectedRomPath, diffCount, mismatchSize, endian=endian, plfResolver=plfResolver))
 
 
 def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser], decompConfig: decomp_settings.Config|None=None):
@@ -200,4 +229,6 @@ def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser],
     parser.add_argument("-m", "--mismatch-size", help="Do not exit early if the ROM sizes does not match", action="store_true")
     parser.add_argument("-e", "--endian", help="Specify endianness of the binary", choices=["big", "little"], default="big")
 
+    parser.add_argument("-x", "--plf-ext", help="File extension for partially linked files (plf). Will be used to transform the `plf`s path into a mapfile path by replacing the extension. The extension must contain the leading period. This argument can be passed multiple times.", action="append")
+
     parser.set_defaults(func=processArguments)

mapfile_parser/frontends/jsonify.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import argparse
+from collections.abc import Callable
 import decomp_settings
 import json
 from pathlib import Path
@@ -13,13 +14,20 @@ from pathlib import Path
 from .. import mapfile
 
 
-def doJsonify(mapPath: Path, outputPath: Path|None, humanReadable: bool=True, applyFixes: bool=False) -> int:
+def doJsonify(
+        mapPath: Path,
+        outputPath: Path|None,
+        humanReadable: bool=True,
+        applyFixes: bool=False,
+        plfResolver: Callable[[Path], Path|None]|None=None,
+    ) -> int:
     if not mapPath.exists():
         print(f"Could not find mapfile at '{mapPath}'")
         return 1
 
-    mapFile = mapfile.MapFile()
-    mapFile.readMapFile(mapPath)
+    mapFile = mapfile.MapFile.newFromMapFile(mapPath)
+    if plfResolver is not None:
+        mapFile = mapFile.resolvePartiallyLinkedFiles(plfResolver)
 
     jsonStr = json.dumps(mapFile.toJson(humanReadable=humanReadable), indent=4)
 
@@ -44,8 +52,20 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
     outputPath: Path|None = Path(args.output) if args.output is not None else None
     machine: bool = args.machine
     applyFixes: bool = args.apply_fixes
+    plfExt: list[str]|None = args.plf_ext
 
-    exit(doJsonify(mapPath, outputPath, humanReadable=not machine, applyFixes=applyFixes))
+    plfResolver = None
+    if plfExt is not None:
+        def resolver(x: Path) -> Path|None:
+            if x.suffix in plfExt:
+                newPath = x.with_suffix(".map")
+                if newPath.exists():
+                    return newPath
+            return None
+
+        plfResolver = resolver
+
+    exit(doJsonify(mapPath, outputPath, humanReadable=not machine, applyFixes=applyFixes, plfResolver=plfResolver))
 
 def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser], decompConfig: decomp_settings.Config|None=None):
     parser = subparser.add_parser("jsonify", help="Converts a mapfile into a json format.")
@@ -67,4 +87,6 @@ def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser],
     parser.add_argument("-m", "--machine", help="Emit numbers as numbers instead of outputting them as pretty strings.", action="store_true")
     parser.add_argument("-f", "--apply-fixes", help="DEPRECATED, this is applied automatically now. Apply certain fixups, like fixing size calculation of because of the existence of fake `.NON_MATCHING` symbols.", action="store_true")
 
+    parser.add_argument("-x", "--plf-ext", help="File extension for partially linked files (plf). Will be used to transform the `plf`s path into a mapfile path by replacing the extension. The extension must contain the leading period. This argument can be passed multiple times.", action="append")
+
     parser.set_defaults(func=processArguments)

mapfile_parser/frontends/objdiff_report.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import argparse
+from collections.abc import Callable
 import dataclasses
 import decomp_settings
 from pathlib import Path
@@ -34,13 +35,15 @@ def doObjdiffReport(
         emitCategories: bool=False,
         quiet: bool=False,
         summaryTableConfig: SummaryTableConfig|None=SummaryTableConfig(),
+        plfResolver: Callable[[Path], Path|None]|None=None,
     ) -> int:
     if not mapPath.exists():
         print(f"Could not find mapfile at '{mapPath}'")
         return 1
 
-    mapFile = mapfile.MapFile()
-    mapFile.readMapFile(mapPath)
+    mapFile = mapfile.MapFile.newFromMapFile(mapPath)
+    if plfResolver is not None:
+        mapFile = mapFile.resolvePartiallyLinkedFiles(plfResolver)
 
     if emitCategories:
         printDefaultCategories(mapFile, prefixesToTrim)
@@ -244,7 +247,11 @@ tools:
   mapfile_parser:
     progress_report:
       # output: report.json # Optional
-      check_asm_paths: True
+      # If you don't have .NON_MATCHING markers in all your function and data
+      # symbols then you should set `check_asm_paths: True` and
+      # `report_data: False`, otherwise those progress will get a fake boost.
+      check_asm_paths: False
+      report_data: True
       # Change if the asm path in the build folder is deeper than two subfolders.
       # i.e.: "build/us/asm/header.o" -> `path_index: 3`.
       # i.e.: "build/us/asm/us/header.o" -> `path_index: 4`.
@@ -274,6 +281,12 @@ tools:
             - {p}
 """, end="")
 
+    print("      # The following categories are autogenerated and they are intended as a")
+    print("      # guide and examples on how to setup your own categories. Please don't")
+    print("      # commit them as-is.")
+    print()
+    print("      # List of categories. `id`s must be unique, but each path may be")
+    print("      # duplicated across categories.")
     print("      categories:")
     print("        # Categories by path")
     printCategories(categoriesByPath)
@@ -310,6 +323,7 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
             pathIndex = int(args.path_index)
         else:
             pathIndex = pathIndexDefault
+        reportCategories.setReportData(settings.reportData)
     else:
         outputPath = args.output
         if args.prefixes_to_trim is not None:
@@ -317,6 +331,7 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
         else:
             prefixesToTrim = []
         pathIndex = int(args.path_index) if args.path_index is not None else pathIndexDefault
+        reportCategories.setReportData(False)
 
     if decompConfig is not None:
         version = decompConfig.get_version_by_name(args.version)
@@ -347,6 +362,18 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
     else:
         summaryTableConfig = None
 
+    plfExt: list[str]|None = args.plf_ext
+
+    plfResolver = None
+    if plfExt is not None:
+        def resolver(x: Path) -> Path|None:
+            if x.suffix in plfExt:
+                newPath = x.with_suffix(".map")
+                if newPath.exists():
+                    return newPath
+            return None
+        plfResolver = resolver
+
     exit(doObjdiffReport(
         mapPath,
         outputPath,
@@ -357,6 +384,7 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
         nonmatchingsPath=nonmatchingsPath,
         emitCategories=emitCategories,
         summaryTableConfig=summaryTableConfig,
+        plfResolver=plfResolver,
     ))
 
 def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser], decompConfig: decomp_settings.Config|None=None):
@@ -386,7 +414,8 @@ tools:
   mapfile_parser:
     progress_report:
       # output: report.json # Optional
-      check_asm_paths: True
+      check_asm_paths: False
+      report_data: True
       # path_index: 2
       # List of build prefixes to trim from each object file
       prefixes_to_trim:
@@ -468,6 +497,8 @@ tools:
     parser.add_argument("--emit-categories", help="Print automatically-generated categories from your mapfile, using the decomp.yaml format. These categories are expected to be tweaked and not used as-is.", action="store_true")
     parser.add_argument("--quiet", help="Avoid printing the progress report to the stdout and to the Github action summary.", action="store_true")
 
+    parser.add_argument("-x", "--plf-ext", help="File extension for partially linked files (plf). Will be used to transform the `plf`s path into a mapfile path by replacing the extension. The extension must contain the leading period. This argument can be passed multiple times.", action="append")
+
     parser.set_defaults(func=processArguments)
 
 
@@ -478,6 +509,7 @@ class SpecificSettings:
     categories: list[Category]
     pathIndex: int|None
     checkAsmPaths: bool
+    reportData: bool
 
     @staticmethod
     def fromDecompConfig(decompConfig: decomp_settings.Config|None=None) -> SpecificSettings|None:
@@ -489,6 +521,7 @@ class SpecificSettings:
         categories: list[Category] = []
         pathIndex: int|None = None
         checkAsmPaths: bool = False
+        reportData = False
         if decompConfig.tools is not None:
             mapfileParserConfig = decompConfig.tools.get("mapfile_parser")
             if mapfileParserConfig is not None:
@@ -512,6 +545,7 @@ class SpecificSettings:
                         if var is not None:
                             pathIndex = var
                         checkAsmPaths = bool(raw.get("check_asm_paths", False))
+                        reportData = bool(raw.get("report_data", False))
 
         return SpecificSettings(
             output,
@@ -519,6 +553,7 @@ class SpecificSettings:
             categories,
             pathIndex,
             checkAsmPaths,
+            reportData,
         )
 
 @dataclasses.dataclass

mapfile_parser/frontends/pj64_syms.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import argparse
+from collections.abc import Callable
 import decomp_settings
 from pathlib import Path
 from typing import TextIO
@@ -21,13 +22,18 @@ def writePj64SymsToFile(mapFile: mapfile.MapFile, outFile: TextIO):
                 symType = "code" if file.sectionType == ".text" else "data"
                 outFile.write(f"{sym.vram:08X},{symType},{sym.name}\n")
 
-def doPj64Syms(mapPath: Path, outputPath: Path|None) -> int:
+def doPj64Syms(
+        mapPath: Path,
+        outputPath: Path|None,
+        plfResolver: Callable[[Path], Path|None]|None=None,
+    ) -> int:
     if not mapPath.exists():
         print(f"Could not find mapfile at '{mapPath}'")
         return 1
 
-    mapFile = mapfile.MapFile()
-    mapFile.readMapFile(mapPath)
+    mapFile = mapfile.MapFile.newFromMapFile(mapPath)
+    if plfResolver is not None:
+        mapFile = mapFile.resolvePartiallyLinkedFiles(plfResolver)
 
     if outputPath is None:
         writePj64SymsToFile(mapFile, sys.stdout)
@@ -48,7 +54,20 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
 
     outputPath: Path = args.output
 
-    exit(doPj64Syms(mapPath, outputPath))
+    plfExt: list[str]|None = args.plf_ext
+
+    plfResolver = None
+    if plfExt is not None:
+        def resolver(x: Path) -> Path|None:
+            if x.suffix in plfExt:
+                newPath = x.with_suffix(".map")
+                if newPath.exists():
+                    return newPath
+            return None
+
+        plfResolver = resolver
+
+    exit(doPj64Syms(mapPath, outputPath, plfResolver=plfResolver))
 
 def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser], decompConfig: decomp_settings.Config|None=None):
     parser = subparser.add_parser("pj64_syms", help="Produce a PJ64 compatible symbol map.")
@@ -68,4 +87,6 @@ def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser],
 
     parser.add_argument("output", help="Path to output file. If omitted then output will be written to stdout", type=Path, nargs="?")
 
+    parser.add_argument("-x", "--plf-ext", help="File extension for partially linked files (plf). Will be used to transform the `plf`s path into a mapfile path by replacing the extension. The extension must contain the leading period. This argument can be passed multiple times.", action="append")
+
     parser.set_defaults(func=processArguments)

mapfile_parser/frontends/progress.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import argparse
+from collections.abc import Callable
 import decomp_settings
 import json
 from pathlib import Path
@@ -14,20 +15,37 @@ from .. import mapfile
 from .. import progress_stats
 
 
-def getProgress(mapPath: Path, asmPath: Path, nonmatchingsPath: Path, pathIndex: int=2, checkFunctionFiles: bool=True, debugging: bool=False) -> tuple[progress_stats.ProgressStats, dict[str, progress_stats.ProgressStats]]:
-    mapFile = mapfile.MapFile()
-
-    mapFile.debugging = debugging
-    mapFile.readMapFile(mapPath)
-
-    return mapFile.filterBySectionType(".text").getProgress(asmPath, nonmatchingsPath, pathIndex=pathIndex, checkFunctionFiles=checkFunctionFiles)
-
-def doProgress(mapPath: Path, asmPath: Path, nonmatchingsPath: Path, pathIndex: int=2, checkFunctionFiles: bool=True, print_json: bool=False, debugging: bool=False) -> int:
+def getProgress(
+        mapPath: Path,
+        asmPath: Path,
+        nonmatchingsPath: Path,
+        pathIndex: int=2,
+        checkFunctionFiles: bool=True,
+        debugging: bool=False,
+        plfResolver: Callable[[Path], Path|None]|None=None,
+    ) -> tuple[progress_stats.ProgressStats, dict[str, progress_stats.ProgressStats]]:
+    mapFile = mapfile.MapFile.newFromMapFile(mapPath)
+    mapFile.filterBySectionType(".text")
+    if plfResolver is not None:
+        mapFile = mapFile.resolvePartiallyLinkedFiles(plfResolver)
+
+    return mapFile.getProgress(asmPath, nonmatchingsPath, pathIndex=pathIndex, checkFunctionFiles=checkFunctionFiles)
+
+def doProgress(
+        mapPath: Path,
+        asmPath: Path,
+        nonmatchingsPath: Path,
+        pathIndex: int=2,
+        checkFunctionFiles: bool=True,
+        print_json: bool=False,
+        debugging: bool=False,
+        plfResolver: Callable[[Path], Path|None]|None=None,
+    ) -> int:
     if not mapPath.exists():
         print(f"Could not find mapfile at '{mapPath}'")
         return 1
 
-    totalStats, progressPerFolder = getProgress(mapPath, asmPath, nonmatchingsPath, pathIndex=pathIndex, checkFunctionFiles=checkFunctionFiles, debugging=debugging)
+    totalStats, progressPerFolder = getProgress(mapPath, asmPath, nonmatchingsPath, pathIndex=pathIndex, checkFunctionFiles=checkFunctionFiles, debugging=debugging, plfResolver=plfResolver)
 
     if print_json:
         json_temp: dict[str, dict[str, int|float]] = {
@@ -59,7 +77,20 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
     debugging: bool = args.debugging #! @deprecated
     print_json: bool = args.json
 
-    exit(doProgress(mapPath, asmPath, nonmatchingsPath, pathIndex=pathIndex, checkFunctionFiles=checkFunctionFiles, print_json=print_json, debugging=debugging))
+    plfExt: list[str]|None = args.plf_ext
+
+    plfResolver = None
+    if plfExt is not None:
+        def resolver(x: Path) -> Path|None:
+            if x.suffix in plfExt:
+                newPath = x.with_suffix(".map")
+                if newPath.exists():
+                    return newPath
+            return None
+
+        plfResolver = resolver
+
+    exit(doProgress(mapPath, asmPath, nonmatchingsPath, pathIndex=pathIndex, checkFunctionFiles=checkFunctionFiles, print_json=print_json, debugging=debugging, plfResolver=plfResolver))
 
 def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser], decompConfig: decomp_settings.Config|None=None):
     parser = subparser.add_parser("progress", help="Computes current progress of the matched functions. Relies on a splat (https://github.com/ethteck/splat) folder structure and matched functions not longer having a file.")
@@ -92,4 +123,6 @@ def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser],
     parser.add_argument("-d", "--debugging", help="Enable debugging prints. This option is deprecated", action="store_true")
     parser.add_argument("-j", "--json", help="Print the stats as json instead of a human readable format.", action="store_true")
 
+    parser.add_argument("-x", "--plf-ext", help="File extension for partially linked files (plf). Will be used to transform the `plf`s path into a mapfile path by replacing the extension. The extension must contain the leading period. This argument can be passed multiple times.", action="append")
+
     parser.set_defaults(func=processArguments)

mapfile_parser/frontends/sym_info.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import argparse
+from collections.abc import Callable
 import decomp_settings
 from pathlib import Path
 
@@ -13,13 +14,22 @@ from .. import mapfile
 from .. import utils
 
 
-def doSymInfo(mapPath: Path, symName: str, *, as_vram: bool=False, as_vrom: bool=False, as_name: bool=False) -> int:
+def doSymInfo(
+        mapPath: Path,
+        symName: str,
+        *,
+        as_vram: bool=False,
+        as_vrom: bool=False,
+        as_name: bool=False,
+        plfResolver: Callable[[Path], Path|None]|None=None,
+    ) -> int:
     if not mapPath.exists():
         print(f"Could not find mapfile at '{mapPath}'")
         return 1
 
-    mapFile = mapfile.MapFile()
-    mapFile.readMapFile(mapPath)
+    mapFile = mapfile.MapFile.newFromMapFile(mapPath)
+    if plfResolver is not None:
+        mapFile = mapFile.resolvePartiallyLinkedFiles(plfResolver)
 
     possibleFiles: list[mapfile.Section] = []
 
@@ -66,8 +76,20 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
     as_vram: bool = args.vram
     as_vrom: bool = args.vrom
     as_name: bool = args.name
+    plfExt: list[str]|None = args.plf_ext
 
-    exit(doSymInfo(mapPath, symName, as_vram=as_vram, as_vrom=as_vrom, as_name=as_name))
+    plfResolver = None
+    if plfExt is not None:
+        def resolver(x: Path) -> Path|None:
+            if x.suffix in plfExt:
+                newPath = x.with_suffix(".map")
+                if newPath.exists():
+                    return newPath
+            return None
+
+        plfResolver = resolver
+
+    exit(doSymInfo(mapPath, symName, as_vram=as_vram, as_vrom=as_vrom, as_name=as_name, plfResolver=plfResolver))
 
 def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser], decompConfig: decomp_settings.Config|None=None):
     parser = subparser.add_parser("sym_info", help="Display various information about a symbol or address.")
@@ -86,6 +108,8 @@ def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser],
         parser.add_argument("mapfile", help="Path to a map file.", type=Path)
     parser.add_argument("symname", help="Symbol name or VROM/VRAM address to lookup. How to treat this argument will be guessed.")
 
+    parser.add_argument("-x", "--plf-ext", help="File extension for partially linked files (plf). Will be used to transform the `plf`s path into a mapfile path by replacing the extension. The extension must contain the leading period. This argument can be passed multiple times.", action="append")
+
     vram_vrom_group = parser.add_mutually_exclusive_group()
     vram_vrom_group.add_argument("--vram", help="Treat the argument as a VRAM address instead of guessing.", action="store_true")
     vram_vrom_group.add_argument("--vrom", help="Treat the argument as a VROM address instead of guessing.", action="store_true")

mapfile_parser/frontends/symbol_sizes_csv.py

@@ -6,19 +6,29 @@
 from __future__ import annotations
 
 import argparse
+from collections.abc import Callable
 import decomp_settings
 from pathlib import Path
 
 from .. import mapfile
 
 
-def doSymbolSizesCsv(mapPath: Path, outputPath: Path|None, filterSection: str|None=None, sameFolder: bool=False, symbolsSummary: bool=False, allFiles: bool=False) -> int:
+def doSymbolSizesCsv(
+        mapPath: Path,
+        outputPath: Path|None,
+        filterSection: str|None=None,
+        sameFolder: bool=False,
+        symbolsSummary: bool=False,
+        allFiles: bool=False,
+        plfResolver: Callable[[Path], Path|None]|None=None,
+    ) -> int:
     if not mapPath.exists():
         print(f"Could not find mapfile at '{mapPath}'")
         return 1
 
-    mapFile = mapfile.MapFile()
-    mapFile.readMapFile(mapPath)
+    mapFile = mapfile.MapFile.newFromMapFile(mapPath)
+    if plfResolver is not None:
+        mapFile = mapFile.resolvePartiallyLinkedFiles(plfResolver)
 
     if filterSection is not None:
         mapFile = mapFile.filterBySectionType(filterSection)
@@ -53,8 +63,20 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
     sameFolder: bool = args.same_folder
     symbolsSummary: bool = args.symbols
     allFiles: bool = args.all
+    plfExt: list[str]|None = args.plf_ext
 
-    exit(doSymbolSizesCsv(mapPath, outputPath, filterSection, sameFolder, symbolsSummary, allFiles))
+    plfResolver = None
+    if plfExt is not None:
+        def resolver(x: Path) -> Path|None:
+            if x.suffix in plfExt:
+                newPath = x.with_suffix(".map")
+                if newPath.exists():
+                    return newPath
+            return None
+
+        plfResolver = resolver
+
+    exit(doSymbolSizesCsv(mapPath, outputPath, filterSection, sameFolder, symbolsSummary, allFiles, plfResolver=plfResolver))
 
 def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser], decompConfig: decomp_settings.Config|None=None):
     parser = subparser.add_parser("symbol_sizes_csv", help="Produces a csv summarizing the files sizes by parsing a map file.")
@@ -78,4 +100,6 @@ def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser],
     parser.add_argument("-a", "--all", help="Don't skip files without symbols.", action="store_true")
     parser.add_argument("-f", "--filter-section", help="Only print the symbols of the passed section. For example: .text")
 
+    parser.add_argument("-x", "--plf-ext", help="File extension for partially linked files (plf). Will be used to transform the `plf`s path into a mapfile path by replacing the extension. The extension must contain the leading period. This argument can be passed multiple times.", action="append")
+
     parser.set_defaults(func=processArguments)

mapfile_parser/frontends/upload_frogress.py

@@ -6,6 +6,7 @@
 from __future__ import annotations
 
 import argparse
+from collections.abc import Callable
 import decomp_settings
 from pathlib import Path
 import requests # type: ignore
@@ -55,12 +56,25 @@ def uploadEntriesToFrogress(entries: dict[str, int], category: str, url: str, ap
     return 0
 
 
-def doUploadFrogress(mapPath: Path, asmPath: Path, nonmatchingsPath: Path, project: str, version: str, category: str, baseurl: str, apikey: str|None=None, verbose: bool=False, checkFunctionFiles: bool=True, dryRun: bool=False) -> int:
+def doUploadFrogress(
+        mapPath: Path,
+        asmPath: Path,
+        nonmatchingsPath: Path,
+        project: str,
+        version: str,
+        category: str,
+        baseurl: str,
+        apikey: str|None=None,
+        verbose: bool=False,
+        checkFunctionFiles: bool=True,
+        dryRun: bool=False,
+        plfResolver: Callable[[Path], Path|None]|None=None,
+    ) -> int:
     if not mapPath.exists():
         print(f"Could not find mapfile at '{mapPath}'")
         return 1
 
-    totalStats, progressPerFolder = progress.getProgress(mapPath, asmPath, nonmatchingsPath, checkFunctionFiles=checkFunctionFiles)
+    totalStats, progressPerFolder = progress.getProgress(mapPath, asmPath, nonmatchingsPath, checkFunctionFiles=checkFunctionFiles, plfResolver=plfResolver)
 
     entries: dict[str, int] = getFrogressEntriesFromStats(totalStats, progressPerFolder, verbose)
 
@@ -89,8 +103,20 @@ def processArguments(args: argparse.Namespace, decompConfig: decomp_settings.Con
     verbose: bool = args.verbose
     checkFunctionFiles: bool = not args.avoid_function_files
     dryRun: bool = args.dry_run
+    plfExt: list[str]|None = args.plf_ext
 
-    exit(doUploadFrogress(mapPath, asmPath, nonmatchingsPath, project, version, category, baseurl, apikey, verbose, checkFunctionFiles, dryRun=dryRun))
+    plfResolver = None
+    if plfExt is not None:
+        def resolver(x: Path) -> Path|None:
+            if x.suffix in plfExt:
+                newPath = x.with_suffix(".map")
+                if newPath.exists():
+                    return newPath
+            return None
+
+        plfResolver = resolver
+
+    exit(doUploadFrogress(mapPath, asmPath, nonmatchingsPath, project, version, category, baseurl, apikey, verbose, checkFunctionFiles, dryRun=dryRun, plfResolver=plfResolver))
 
 def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser], decompConfig: decomp_settings.Config|None=None):
     parser = subparser.add_parser("upload_frogress", help="Uploads current progress of the matched functions to frogress (https://github.com/decompals/frogress).")
@@ -132,4 +158,6 @@ def addSubparser(subparser: argparse._SubParsersAction[argparse.ArgumentParser],
     parser.add_argument("-f", "--avoid-function-files", help="Avoid checking if the assembly file for a function exists as a way to determine if the function has been matched or not", action="store_true")
     parser.add_argument("-d", "--dry-run", help="Stop before uploading the progress.", action="store_true")
 
+    parser.add_argument("-x", "--plf-ext", help="File extension for partially linked files (plf). Will be used to transform the `plf`s path into a mapfile path by replacing the extension. The extension must contain the leading period. This argument can be passed multiple times.", action="append")
+
     parser.set_defaults(func=processArguments)

mapfile_parser/mapfile.py

@@ -5,6 +5,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 import dataclasses
 import re
 from typing import Any, Generator
@@ -99,6 +100,7 @@ class Symbol:
     Note the symbol with the actual `.NON_MATCHING` will have this member
     set to `false`.
     """
+    inferredStatic: bool = False
 
     def getVramStr(self) -> str:
         return f"0x{self.vram:08X}"
@@ -159,7 +161,7 @@ class Symbol:
 
 
     def clone(self) -> Symbol:
-        return Symbol(self.name, self.vram, self.size, self.vrom, self.align)
+        return Symbol(self.name, self.vram, self.size, self.vrom, self.align, self.nonmatchingSymExists, self.inferredStatic)
 
 
     def __eq__(self, other: object) -> bool:
@@ -377,7 +379,7 @@ class Section:
 
 
     def clone(self) -> Section:
-        f = Section(self.filepath, self.vram, self.size, self.sectionType, self.vrom, self.align)
+        f = Section(self.filepath, self.vram, self.size, self.sectionType, self.vrom, self.align, self.isFill)
         for sym in self._symbols:
             f._symbols.append(sym.clone())
         return f
@@ -449,7 +451,7 @@ class Segment:
                 newSegment._sectionsList.append(section)
         return newSegment
 
-    #! @deprecated: Use either `getEverySectionExceptSectionType` instead.
+    #! @deprecated: Use `getEverySectionExceptSectionType` instead.
     def getEveryFileExceptSectionType(self, sectionType: str) -> Segment:
         return self.getEverySectionExceptSectionType(sectionType)
 
@@ -588,28 +590,31 @@ class Segment:
         self._sectionsList.append(section)
 
 
-    #! @deprecated: Use either `copySectionList` instead.
+    #! @deprecated: Use `copySectionList` instead.
     def copyFileList(self) -> list[Section]:
         """Returns a copy (not a reference) of the internal section list"""
         return self.copySectionList()
 
-    #! @deprecated: Use either `setSectionList` instead.
+    #! @deprecated: Use `setSectionList` instead.
     def setFileList(self, newList: list[Section]) -> None:
         """Replaces the internal section list with a copy of `newList`"""
         return self.setSectionList(newList)
 
-    #! @deprecated: Use either `appendSection` instead.
+    #! @deprecated: Use `appendSection` instead.
     def appendFile(self, section: Section) -> None:
         """Appends a copy of `section` into the internal section list"""
         return self.appendSection(section)
 
 
     def clone(self) -> Segment:
-        s = Segment(self.name, self.vram, self.size, self.vrom, self.align)
+        s = self.cloneNoSectionlist()
         for f in self._sectionsList:
             s._sectionsList.append(f.clone())
         return s
 
+    def cloneNoSectionlist(self) -> Segment:
+        return Segment(self.name, self.vram, self.size, self.vrom, self.align)
+
 
     def __iter__(self) -> Generator[Section, None, None]:
         for section in self._sectionsList:
@@ -683,7 +688,7 @@ class MapFile:
             for section in segment:
                 newSection = Section(section.filepath, section.vram, section.size, section.sectionType, section.vrom, section.align, section.isFill)
                 for symbol in section:
-                    newSymbol = Symbol(symbol.name, symbol.vram, symbol.size, symbol.vrom, symbol.align, symbol.nonmatchingSymExists)
+                    newSymbol = Symbol(symbol.name, symbol.vram, symbol.size, symbol.vrom, symbol.align, symbol.nonmatchingSymExists, symbol.inferredStatic)
 
                     newSection._symbols.append(newSymbol)
                 newSegment._sectionsList.append(newSection)
@@ -698,7 +703,7 @@ class MapFile:
                 newSection = SectionRs(section.filepath, section.vram, section.size, section.sectionType, section.vrom, section.align, section.isFill)
                 for symbol in section._symbols:
                     size = symbol.size if symbol.size is not None else 0
-                    newSymbol = SymbolRs(symbol.name, symbol.vram, size, symbol.vrom, symbol.align, symbol.nonmatchingSymExists)
+                    newSymbol = SymbolRs(symbol.name, symbol.vram, size, symbol.vrom, symbol.align, symbol.nonmatchingSymExists, symbol.inferredStatic)
 
                     newSection.appendSymbol(newSymbol)
                 newSegment.appendFile(newSection)
@@ -706,7 +711,7 @@ class MapFile:
 
         return nativeMapFile
 
-    #! @deprecated: Use either `newFromMapFile` instead.
+    #! @deprecated: Use `newFromMapFile` instead.
     def readMapFile(self, mapPath: Path):
         """
         Opens the mapfile pointed by the `mapPath` argument and parses it.
@@ -719,12 +724,11 @@ class MapFile:
         - Metrowerks ld
         """
 
-        nativeMapFile = MapFileRs()
-        nativeMapFile.readMapFile(mapPath)
+        nativeMapFile = MapFileRs.newFromMapFile(mapPath)
 
         self._transferContentsFromNativeMapFile(nativeMapFile)
 
-    #! @deprecated: Use either `newFromMapStr` instead.
+    #! @deprecated: Use `newFromMapStr` instead.
     def parseMapContents(self, mapContents: str):
         """
         Parses the contents of the map.
@@ -739,12 +743,11 @@ class MapFile:
         - Metrowerks ld
         """
 
-        nativeMapFile = MapFileRs()
-        nativeMapFile.parseMapContents(mapContents)
+        nativeMapFile = MapFileRs.newFromMapStr(mapContents)
 
         self._transferContentsFromNativeMapFile(nativeMapFile)
 
-    #! @deprecated: Use either `newFromGnuMapStr` instead.
+    #! @deprecated: Use `newFromGnuMapStr` instead.
     def parseMapContentsGNU(self, mapContents: str):
         """
         Parses the contents of a GNU ld map.
@@ -752,12 +755,11 @@ class MapFile:
         The `mapContents` argument must contain the contents of a GNU ld mapfile.
         """
 
-        nativeMapFile = MapFileRs()
-        nativeMapFile.parseMapContentsGNU(mapContents)
+        nativeMapFile = MapFileRs.newFromGnuMapStr(mapContents)
 
         self._transferContentsFromNativeMapFile(nativeMapFile)
 
-    #! @deprecated: Use either `newFromLldMapStr` instead.
+    #! @deprecated: Use `newFromLldMapStr` instead.
     def parseMapContentsLLD(self, mapContents: str):
         """
         Parses the contents of a clang ld.lld map.
@@ -765,8 +767,7 @@ class MapFile:
         The `mapContents` argument must contain the contents of a clang ld.lld mapfile.
         """
 
-        nativeMapFile = MapFileRs()
-        nativeMapFile.parseMapContentsLLD(mapContents)
+        nativeMapFile = MapFileRs.newFromLldMapStr(mapContents)
 
         self._transferContentsFromNativeMapFile(nativeMapFile)
 
@@ -1015,6 +1016,86 @@ class MapFile:
 
         return compInfo
 
+    def resolvePartiallyLinkedFiles(self, resolver: Callable[[Path], Path|None]) -> MapFile:
+        """
+        Resolve sections and paths of a mapfile built from partially linked objects.
+
+        `elf` files built by using partially linked files/objects (usually
+        referred to as `plf`) usually generate mapfiles that have filepaths that
+        point to the partially linked objects instead of the original objects
+        used to build those intermediary objects, making it awkward to work with
+        paths because all symbols will be listed as part as the same single `plf`.
+
+        This function resolves those sections by using a resolver callback that
+        transforms a path to an object/`plf` into the corresponding mapfile of
+        said partially linked object.
+        This callback should return `None` if the given path does not correspond
+        to a `plf`, the pointed mapfile does not exist, etc.
+
+        An usual convention for a file extension for partially linked objects is
+        the `.plf` extension instead of `.o`.
+        """
+
+        # Construct a mapping for every "plf -> map"
+        knownMaps: dict[Path, MapFile] = dict()
+        for seg in self._segmentsList:
+            for sect in seg._sectionsList:
+                # Only read the map if this is a new plf.
+                if sect.filepath in knownMaps:
+                    continue
+                if (other_map_path := resolver(sect.filepath)) is not None:
+                    knownMaps[sect.filepath] = MapFile.newFromMapFile(other_map_path)
+        return self._resolve_plf_impl(knownMaps)
+
+    def _resolve_plf_impl(self, knownMaps: dict[Path, MapFile]) -> MapFile:
+        if len(knownMaps) == 0:
+            return self.clone()
+
+        resolvedMap = MapFile()
+        for seg in self._segmentsList:
+            newSeg = seg.cloneNoSectionlist()
+
+            for sect in seg._sectionsList:
+                if (otherMap := knownMaps.get(sect.filepath)) is not None:
+                    # Each segment of a plf is just a normal elf section
+                    partialSegment = None
+                    for x in otherMap._segmentsList:
+                        if x.name == sect.sectionType:
+                            partialSegment = x
+                            break
+
+                    if partialSegment is not None:
+                        # Take all the sections from the plf map and insert them
+                        # into the new generated map, replacing the old sections
+                        # and symbols.
+                        for partialSect in partialSegment._sectionsList:
+                            sectTemp = partialSect.clone()
+
+                            # Adjust the vram and vrom addresses of the section
+                            # because they are relative to zero.
+                            sectTemp.vram += sect.vram - partialSegment.vram
+                            if sectTemp.vrom is not None and sect.vrom is not None and partialSegment.vrom is not None:
+                                sectTemp.vrom = sectTemp.vrom + sect.vrom - partialSegment.vrom
+
+                            # Adjust vram and vrom of symbols too.
+                            for partialSym in sectTemp._symbols:
+                                partialSym.vram += sect.vram - partialSegment.vram
+                                if partialSym.vrom is not None and sect.vrom is not None and partialSegment.vrom is not None:
+                                    partialSym.vrom = partialSym.vrom + sect.vrom - partialSegment.vrom
+
+                            newSeg._sectionsList.append(sectTemp)
+                    else:
+                        # Keep the original section if there are no sections
+                        # matching the section type in the plf.
+                        newSeg._sectionsList.append(sect.clone())
+                else:
+                    # Keep the original section if there are no maps for this path
+                    newSeg._sectionsList.append(sect.clone())
+                pass
+
+            resolvedMap._segmentsList.append(newSeg)
+        return resolvedMap
+
 
     def printAsCsv(self, printVram: bool=True, skipWithoutSymbols: bool=True):
         print(self.toCsv(printVram=printVram, skipWithoutSymbols=skipWithoutSymbols), end="")

mapfile_parser/mapfile_parser.pyi

@@ -82,8 +82,18 @@ class Symbol:
     vrom: int|None
     align: int|None
     nonmatchingSymExists: bool
-
-    def __init__(self, name: str, vram: int, size: int=0, vrom: int|None=None, align: int|None=None, nonmatchingSymExists: bool=False): ...
+    inferredStatic: bool
+
+    def __init__(
+        self,
+        name: str,
+        vram: int,
+        size: int=0,
+        vrom: int|None=None,
+        align: int|None=None,
+        nonmatchingSymExists: bool=False,
+        inferredStatic: bool=False,
+    ): ...
 
     def getVramStr(self) -> str: ...
     def getSizeStr(self) -> str: ...
@@ -301,6 +311,23 @@ class MapFile:
     def __len__(self) -> int: ...
 
 class ReportCategories:
+    """
+    Allows configuring certain aspects of the generated objdiff report file,
+    like categories.
+    """
     def __init__(self): ...
 
-    def push(self, id: str, name: str, paths: list[str]): ...
+    def push(self, id: str, name: str, paths: list[str]):
+        """
+        Add a category with the given list of paths.
+
+        If the category id already exists then the paths are merged together
+        with the previous list of paths.
+        """
+
+    def setReportData(self, reportData: bool):
+        """
+        Track data progress on the generated report file.
+
+        Defaults to `True`.
+        """

{mapfile_parser-2.9.4.dist-info → mapfile_parser-2.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapfile_parser
-Version: 2.9.4
+Version: 2.11.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -8,10 +8,6 @@ Requires-Dist: requests
 Requires-Dist: decomp-settings==0.0.9
 License-File: LICENSE
 Summary: Map file parser library focusing decompilation projects
-Keywords: mapfile,parser,decomp,decompilation
-Author: Anghelo Carvajal <angheloalf95@gmail.com>
-Author-email: Anghelo Carvajal <angheloalf95@gmail.com>
-License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Homepage, https://github.com/Decompollaborate/mapfile_parser
@@ -55,7 +51,7 @@ If you use a `requirements.txt` file in your repository, then you can add
 this library with the following line:
 
 ```txt
-mapfile_parser>=2.9.4,<3.0.0
+mapfile_parser>=2.11.0,<3.0.0
 ```
 
 #### Development version
@@ -94,7 +90,7 @@ cargo add mapfile_parser
 Or add the following line manually to your `Cargo.toml` file:
 
 ```toml
-mapfile_parser = "2.9.4"
+mapfile_parser = "2.11.0"
 ```
 
 ## Versioning and changelog

mapfile_parser-2.11.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+mapfile_parser-2.11.0.dist-info/METADATA,sha256=QqhGok_sqwGuZxwfsJ6RQrI5Wngf1VPftpl7QGtwAEE,5773
+mapfile_parser-2.11.0.dist-info/WHEEL,sha256=Iz7QqxpWQRXToFIDkGspPPKDuV_klwuhW8ziiU5jhR8,96
+mapfile_parser-2.11.0.dist-info/licenses/LICENSE,sha256=8N8dS9WOtgJ0rkqNNOcazXKVkD2umzsKSHI0bd2HhG0,1094
+mapfile_parser/__init__.py,sha256=39UcAN6YfyE1M7ZedKbW1qNQUm6krvcPcQyPTxtV2hM,884
+mapfile_parser/__main__.py,sha256=BxL4C_wPsFHjvdYkqmL7O3AmvVs9DG34S6Quu843tgs,2235
+mapfile_parser/frontends/__init__.py,sha256=42Wut4H28j9TjPcADXjPtz5oJ-snrfCDcjotOvReo0k,529
+mapfile_parser/frontends/bss_check.py,sha256=JWCSkF6s3JwtKIfJomvp-qid-vbPsPA6CDGK4i6SsB4,9894
+mapfile_parser/frontends/first_diff.py,sha256=I6Nml3EXg3yVnumdXLa7NlIUnUqoqznKQYLfT9Dlnh4,10271
+mapfile_parser/frontends/jsonify.py,sha256=ZDdW_CvoXTc93Ypm9WI0_dJ4pzfiACrQNg2YN1r1-iM,3642
+mapfile_parser/frontends/objdiff_report.py,sha256=1sEvKg87WpiTpim3xSJRCbVdjlm8QaH7w0dbkYgPcl8,21247
+mapfile_parser/frontends/pj64_syms.py,sha256=mLsJCwKbYlIyAxAi7hXPnP8C9oACZ0_x_Rgc9HFEwyg,3305
+mapfile_parser/frontends/progress.py,sha256=3_qWedz55MamSlb3htPj-n8o4q7PN_0_fPtnyDRV2qM,5729
+mapfile_parser/frontends/sym_info.py,sha256=zoy8dq5bI_jlqld7FuJwjrJbnbictEYJQiNrBjh4oIM,4566
+mapfile_parser/frontends/symbol_sizes_csv.py,sha256=DEP0612IYaQm9x1UauOU7QHtIXtlRQJCsE-a1GdeceA,4155
+mapfile_parser/frontends/upload_frogress.py,sha256=xZji60WnQzL_ojQ39v4Ki0G7wgnMlH-NMEyLYfQ2AGM,6691
+mapfile_parser/internals/__init__.py,sha256=lA5cxXEs9jtz1O5I68rtpEnz3LozDqNAOxV7GmyW2tg,340
+mapfile_parser/internals/objdiff_report.py,sha256=KBNuqjMxXMXZllqLJd4V-wUFFynLK4qT2UIJgjXKysI,6401
+mapfile_parser/mapfile.py,sha256=vuY7uzzH_jPi8k2EItdRg2H0YXJfTVuEPwGWm2AFv7w,44220
+mapfile_parser/mapfile_parser.cp310-win_amd64.pyd,sha256=afVQDjCgHcpst8bhqPeKnlSMSXmmMdMjDh4_9_egt5s,2593792
+mapfile_parser/mapfile_parser.pyi,sha256=hXSuhmUFEqP6tgNXPsB2HwN-LlOq_r2i4n6_GN6R3js,12149
+mapfile_parser/mapfile_rs.py,sha256=7xLjYmXZ-o6FKy5I40U-9mc6wRY413zgW8fGSFvz278,4199
+mapfile_parser/progress_stats.py,sha256=yHA0u1-5-RPEl5bBMM1kxUdp0hlJWsp8S97J8LfOaNc,2604
+mapfile_parser/progress_stats_rs.py,sha256=5b7uw84OQZUchPlNgosfosifOu9aa5tEz_sUdJGuywo,499
+mapfile_parser/utils.py,sha256=TY1Xibb88dL8-2PwLVkmahhIYdBJk_6MLPQ3BUzrh70,1572
+mapfile_parser-2.11.0.dist-info/RECORD,,

{mapfile_parser-2.9.4.dist-info → mapfile_parser-2.11.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.8.6)
+Generator: maturin (1.9.4)
 Root-Is-Purelib: false
 Tag: cp310-cp310-win_amd64

mapfile_parser-2.9.4.dist-info/RECORD

@@ -1,25 +0,0 @@
-mapfile_parser-2.9.4.dist-info/METADATA,sha256=fZzUkQvB6y3Zha_IKA_PdIWndOw255GzMVxZTMBxmk8,5935
-mapfile_parser-2.9.4.dist-info/WHEEL,sha256=tvMehAuwYswG9dMmwHb6RW7O-9AAAcnneXQ2akCAgrw,96
-mapfile_parser-2.9.4.dist-info/licenses/LICENSE,sha256=8N8dS9WOtgJ0rkqNNOcazXKVkD2umzsKSHI0bd2HhG0,1094
-mapfile_parser/__init__.py,sha256=E_Auvz0aTyah2osA_6O_R5eP3FX1Ygca1muCFAkcRe4,883
-mapfile_parser/__main__.py,sha256=BxL4C_wPsFHjvdYkqmL7O3AmvVs9DG34S6Quu843tgs,2235
-mapfile_parser/frontends/__init__.py,sha256=42Wut4H28j9TjPcADXjPtz5oJ-snrfCDcjotOvReo0k,529
-mapfile_parser/frontends/bss_check.py,sha256=-CiP5UvlKKUGoUHQwuOoEYD9T9UDmkUxL7PpmlONih8,8524
-mapfile_parser/frontends/first_diff.py,sha256=7aeVSwaJ9WuktU4lxZKJvKCttp0exnOGEMs6Pb1pFo4,9102
-mapfile_parser/frontends/jsonify.py,sha256=Epb_uZO-sfZ8DjRgKT_whVrYfbtGFm3Lv9ajkRWXlyw,2724
-mapfile_parser/frontends/objdiff_report.py,sha256=aLamem6P2LpfaeWA5TbEj4YMtMqKp7EdHXgvYrnzoYc,19458
-mapfile_parser/frontends/pj64_syms.py,sha256=TeIApSG5MIeQS_f9yVcaL9jAPwu0tvtXrzO1OIKV4bY,2403
-mapfile_parser/frontends/progress.py,sha256=g5sKRg0Lij0j9td_fefC33dqP4VB-mAy4jZNbODLUIw,4658
-mapfile_parser/frontends/sym_info.py,sha256=TpyFLCCtzxRZVJoHjz8ObGVl36PVmZQkMM5_kER8vtQ,3630
-mapfile_parser/frontends/symbol_sizes_csv.py,sha256=75qIZv7E1-DZgGuuWj3_XTaVKjF1gLNt5IBh-Ox6OT8,3219
-mapfile_parser/frontends/upload_frogress.py,sha256=UNRw5VfWxHZtzr5zfRbZ6xi_ojTbZZ5uGV-R6Q5qGJE,5774
-mapfile_parser/internals/__init__.py,sha256=lA5cxXEs9jtz1O5I68rtpEnz3LozDqNAOxV7GmyW2tg,340
-mapfile_parser/internals/objdiff_report.py,sha256=KBNuqjMxXMXZllqLJd4V-wUFFynLK4qT2UIJgjXKysI,6401
-mapfile_parser/mapfile.py,sha256=IgztKA_yORsCCvcjrMzX7NRWdExBj93m-2E3a60azzE,39913
-mapfile_parser/mapfile_parser.cp310-win_amd64.pyd,sha256=D7r209kwlo8_UqV5pJUAhB5jErIBPjvCEluGBgCvMzY,2608128
-mapfile_parser/mapfile_parser.pyi,sha256=K8bf1H1DXoa9cSIzjhJQTedNM-HtJnPRX1eVBu_26RM,11533
-mapfile_parser/mapfile_rs.py,sha256=7xLjYmXZ-o6FKy5I40U-9mc6wRY413zgW8fGSFvz278,4199
-mapfile_parser/progress_stats.py,sha256=yHA0u1-5-RPEl5bBMM1kxUdp0hlJWsp8S97J8LfOaNc,2604
-mapfile_parser/progress_stats_rs.py,sha256=5b7uw84OQZUchPlNgosfosifOu9aa5tEz_sUdJGuywo,499
-mapfile_parser/utils.py,sha256=TY1Xibb88dL8-2PwLVkmahhIYdBJk_6MLPQ3BUzrh70,1572
-mapfile_parser-2.9.4.dist-info/RECORD,,