mapfile-parser 2.9.4__cp39-cp39-musllinux_1_2_armv7l.whl → 2.10.0__cp39-cp39-musllinux_1_2_armv7l.whl

mapfile_parser/__init__.py

@@ -5,7 +5,7 @@
 
 from __future__ import annotations
 
-__version_info__ = (2, 9, 4)
+__version_info__ = (2, 10, 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)
@@ -347,6 +350,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 +372,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):
@@ -468,6 +484,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)
 
 

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
@@ -159,7 +160,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)
 
 
     def __eq__(self, other: object) -> bool:
@@ -377,7 +378,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 +450,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 +589,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:
@@ -706,7 +710,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 +723,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 +742,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 +754,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 +766,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 +1015,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
+                            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
+                                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-2.9.4.dist-info → mapfile_parser-2.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapfile_parser
-Version: 2.9.4
+Version: 2.10.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.10.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.10.0"
 ```
 
 ## Versioning and changelog

mapfile_parser-2.10.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+mapfile_parser-2.10.0.dist-info/METADATA,sha256=bev5YplmuDHyinu7Z-YeBA2vOfcRkaAGlv84q64RGMs,5648
+mapfile_parser-2.10.0.dist-info/WHEEL,sha256=qh5btqjVHmZ0HjWePGI70zAW_wMd0f-tWtnLMFx5EDA,105
+mapfile_parser-2.10.0.dist-info/licenses/LICENSE,sha256=FT7oxTcFUtz2c5eYIYePfzj2UD3hvxtLTa3FWz_nJuM,1073
+mapfile_parser.libs/libgcc_s-0366c7ba.so.1,sha256=QjFj5R7pVqB-p92h2JTCmlyfd3UKsVGW_Y_l3SqOAaU,2753157
+mapfile_parser/__init__.py,sha256=_IAX_b96JCG31ewTcS4cBCQW2hKV878G6ThikxqUEks,856
+mapfile_parser/__main__.py,sha256=vErQTK2miHF7NseqLgI567tbFUjOrQ7UNxXOr_FwBhc,2176
+mapfile_parser/frontends/__init__.py,sha256=RIUBbM6crp4V4EeMQy0whTonYauh0Oi2oaxu1NfWNao,512
+mapfile_parser/frontends/bss_check.py,sha256=RierwrcKodWAf_-lD4xm9CjF_gh7ponlx0qEacRXKBk,9666
+mapfile_parser/frontends/first_diff.py,sha256=DyQRGHlYTVgfqEo6S25l335DgfJa2XbJ_V37-RQPmjM,10037
+mapfile_parser/frontends/jsonify.py,sha256=xchQspD7p0ai4ZzcKNgLN8pF9K56BGZN0YfcSUwWS5A,3550
+mapfile_parser/frontends/objdiff_report.py,sha256=2PnRn8dNBfAYNyixxT88PvQVcRggWB-YeDD9KDR-rSE,19767
+mapfile_parser/frontends/pj64_syms.py,sha256=uQKjBM7qSAfeD9GvURpb_k-TdzynY3XINjp5jli_oJw,3213
+mapfile_parser/frontends/progress.py,sha256=QAzuds8q9gZVin7fgfeB_1bjKwnNYTfd31P_6rOHnRA,5601
+mapfile_parser/frontends/sym_info.py,sha256=10AA3CCIEvyjhnp9nOldaPeh2AdQpwh5vH79-1yVknc,4448
+mapfile_parser/frontends/symbol_sizes_csv.py,sha256=Jr9hBYsMpq7sbLgMLiNi8u_qNXlAy1pOyTZKVvnI_hA,4050
+mapfile_parser/frontends/upload_frogress.py,sha256=PD9XupSd5LeD-xMjVUOjWDcQqK3gt4-1ykf7VVGBMoU,6528
+mapfile_parser/internals/__init__.py,sha256=WW--q8KRIfYTQLOMvRO7PCMSf7uWk-I1T20KU0C2a_0,327
+mapfile_parser/internals/objdiff_report.py,sha256=sZh7rUHdoWJfZKQ3EIeuNH9LqdEis2t7heCo1OOwKJU,6214
+mapfile_parser/mapfile.py,sha256=FSWKugZL_F2stvJ8o1MdgvaBeEJhJRRpm62JQ2TG_JA,42916
+mapfile_parser/mapfile_parser.cpython-39-arm-linux-gnueabihf.so,sha256=wmpBNKCWuT4GOWFHqvO5b_4v7BK_pWO-SPIYUFZ6Cm0,3152869
+mapfile_parser/mapfile_parser.pyi,sha256=AuaCWiMySw-oBr-AR2NSbYbhpVP8TGS16rMeey6wc28,11227
+mapfile_parser/mapfile_rs.py,sha256=0sVtLGvz5SMH5bKeTYu-3sM0f-_xXFRfDyY2g1GDh54,4078
+mapfile_parser/progress_stats.py,sha256=T9V52QIoNBtvsPAbYRlCOAio95Z8VxzZep8bCc1J-H0,2535
+mapfile_parser/progress_stats_rs.py,sha256=Rc9-PuZoKWVTO9TEIRk3Mpw0v6FdCFaJk2h7jUGyT_0,483
+mapfile_parser/utils.py,sha256=Bz6pcuR9lax72Y7avgbOIBlyN-1GcxfDxz5iBodr3n0,1517
+mapfile_parser-2.10.0.dist-info/RECORD,,

{mapfile_parser-2.9.4.dist-info → mapfile_parser-2.10.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: cp39-cp39-musllinux_1_2_armv7l

mapfile_parser-2.9.4.dist-info/RECORD

@@ -1,26 +0,0 @@
-mapfile_parser-2.9.4.dist-info/METADATA,sha256=caVcmO4gT_gP9yjCNcy8wWsLvAq20B3gtz95fQ3VfKU,5810
-mapfile_parser-2.9.4.dist-info/WHEEL,sha256=3pmQ0_GUz8dFwucgTjtVJ_sBRdaTjahuPVfbh3xRtdg,105
-mapfile_parser-2.9.4.dist-info/licenses/LICENSE,sha256=FT7oxTcFUtz2c5eYIYePfzj2UD3hvxtLTa3FWz_nJuM,1073
-mapfile_parser.libs/libgcc_s-5b5488a6.so.1,sha256=HGKUsVmTeNAxEdSy7Ua5Vh_I9FN3RCbPWzvZ7H_TrwE,2749061
-mapfile_parser/__init__.py,sha256=LXglMB86pxkPrX_nAqAY2Ma_QV4xfGwmEpV9-a6LTy4,855
-mapfile_parser/__main__.py,sha256=vErQTK2miHF7NseqLgI567tbFUjOrQ7UNxXOr_FwBhc,2176
-mapfile_parser/frontends/__init__.py,sha256=RIUBbM6crp4V4EeMQy0whTonYauh0Oi2oaxu1NfWNao,512
-mapfile_parser/frontends/bss_check.py,sha256=O50pVG8uCp7poEqtrCbh05eIC_TYq3OIaD5VCZz4xGQ,8328
-mapfile_parser/frontends/first_diff.py,sha256=P5CqdGM_X7-WCcW7ubktKI6fnhHxezc1R0aL4_v3bOA,8899
-mapfile_parser/frontends/jsonify.py,sha256=Xq4fha2wJ70WH0an4BXaLnwgjYhNgAwTvrZZZoicRNQ,2654
-mapfile_parser/frontends/objdiff_report.py,sha256=d3I9PgjFIbWIoz_ZDAz58CMOMDrHNEiXwLOAVIlTzUo,18902
-mapfile_parser/frontends/pj64_syms.py,sha256=mJwiVGKGBoNrI-6VB4UJSVz7mIlihivX3KvUGRtoyMY,2332
-mapfile_parser/frontends/progress.py,sha256=j-6OtUCx8af8f3mcy1njA8AEEkR3mYf9_caCh-gFWDY,4563
-mapfile_parser/frontends/sym_info.py,sha256=CGpMdOHUpZslvTe8RpGJ-xrYhEjkhuzYKSJS4FZ60WI,3536
-mapfile_parser/frontends/symbol_sizes_csv.py,sha256=HMOBwAu_pN5dufiT-SEGg7cnIAVkyIDmVelP3YIyq0c,3138
-mapfile_parser/frontends/upload_frogress.py,sha256=ei3pSz2rzVpDj-0CASnPuyqqhu5Lm90mZ_2tsbF9ALU,5639
-mapfile_parser/internals/__init__.py,sha256=WW--q8KRIfYTQLOMvRO7PCMSf7uWk-I1T20KU0C2a_0,327
-mapfile_parser/internals/objdiff_report.py,sha256=sZh7rUHdoWJfZKQ3EIeuNH9LqdEis2t7heCo1OOwKJU,6214
-mapfile_parser/mapfile.py,sha256=498NSrZtorSe-W0BzxnMtq-d0xOBBcaj8fB9iRK4Tmg,38834
-mapfile_parser/mapfile_parser.cpython-39-arm-linux-gnueabihf.so,sha256=13efsrFLy0QUnKzOgQ-vkC9ND9noaJeZLoEjvOs7M0k,3185637
-mapfile_parser/mapfile_parser.pyi,sha256=AuaCWiMySw-oBr-AR2NSbYbhpVP8TGS16rMeey6wc28,11227
-mapfile_parser/mapfile_rs.py,sha256=0sVtLGvz5SMH5bKeTYu-3sM0f-_xXFRfDyY2g1GDh54,4078
-mapfile_parser/progress_stats.py,sha256=T9V52QIoNBtvsPAbYRlCOAio95Z8VxzZep8bCc1J-H0,2535
-mapfile_parser/progress_stats_rs.py,sha256=Rc9-PuZoKWVTO9TEIRk3Mpw0v6FdCFaJk2h7jUGyT_0,483
-mapfile_parser/utils.py,sha256=Bz6pcuR9lax72Y7avgbOIBlyN-1GcxfDxz5iBodr3n0,1517
-mapfile_parser-2.9.4.dist-info/RECORD,,