splat64 0.32.2__py3-none-any.whl → 0.33.0__py3-none-any.whl

splat/__init__.py

@@ -1,7 +1,7 @@
 __package_name__ = __name__
 
 # Should be synced with pyproject.toml
-__version__ = "0.32.2"
+__version__ = "0.33.0"
 __author__ = "ethteck"
 
 from . import util as util

splat/disassembler/spimdisasm_disassembler.py

@@ -7,7 +7,7 @@ from typing import Set
 
 class SpimdisasmDisassembler(disassembler.Disassembler):
     # This value should be kept in sync with the version listed on requirements.txt and pyproject.toml
-    SPIMDISASM_MIN = (1, 32, 0)
+    SPIMDISASM_MIN = (1, 33, 0)
 
     def configure(self):
         # Configure spimdisasm

splat/scripts/split.py

@@ -10,10 +10,6 @@ from .. import __package_name__, __version__
 from ..disassembler import disassembler_instance
 from ..util import cache_handler, progress_bar, vram_classes, statistics
 
-# This unused import makes the yaml library faster. don't remove
-import pylibyaml  # pyright: ignore
-import yaml
-
 from colorama import Fore, Style
 from intervaltree import Interval, IntervalTree
 import sys
@@ -23,7 +19,7 @@ from ..segtypes.linker_entry import (
     get_segment_vram_end_symbol_name,
 )
 from ..segtypes.segment import Segment
-from ..util import log, options, palettes, symbols, relocs
+from ..util import conf, log, options, palettes, symbols, relocs
 
 linker_writer: LinkerWriter
 config: Dict[str, Any]
@@ -142,34 +138,6 @@ def assign_symbols_to_segments():
                     seg.add_symbol(symbol)
 
 
-def merge_configs(main_config, additional_config):
-    # Merge rules are simple
-    # For each key in the dictionary
-    # - If list then append to list
-    # - If a dictionary then repeat merge on sub dictionary entries
-    # - Else assume string or number and replace entry
-
-    for curkey in additional_config:
-        if curkey not in main_config:
-            main_config[curkey] = additional_config[curkey]
-        elif type(main_config[curkey]) != type(additional_config[curkey]):
-            log.error(f"Type for key {curkey} in configs does not match")
-        else:
-            # keys exist and match, see if a list to append
-            if type(main_config[curkey]) == list:
-                main_config[curkey] += additional_config[curkey]
-            elif type(main_config[curkey]) == dict:
-                # need to merge sub areas
-                main_config[curkey] = merge_configs(
-                    main_config[curkey], additional_config[curkey]
-                )
-            else:
-                # not a list or dictionary, must be a number or string, overwrite
-                main_config[curkey] = additional_config[curkey]
-
-    return main_config
-
-
 def brief_seg_name(seg: Segment, limit: int, ellipsis="…") -> str:
     s = seg.name.strip()
     if len(s) > limit:
@@ -203,25 +171,6 @@ def calc_segment_dependences(
     return vram_class_to_follows_segments
 
 
-def initialize_config(
-    config_path: List[str],
-    modes: Optional[List[str]],
-    verbose: bool,
-    disassemble_all: bool = False,
-) -> Dict[str, Any]:
-    config: Dict[str, Any] = {}
-    for entry in config_path:
-        with open(entry) as f:
-            additional_config = yaml.load(f.read(), Loader=yaml.SafeLoader)
-        config = merge_configs(config, additional_config)
-
-    vram_classes.initialize(config.get("vram_classes"))
-
-    options.initialize(config, config_path, modes, verbose, disassemble_all)
-
-    return config
-
-
 def read_target_binary() -> bytes:
     rom_bytes = options.opts.target_path.read_bytes()
 
@@ -493,20 +442,27 @@ def dump_symbols() -> None:
 
 
 def main(
-    config_path: List[str],
+    config_path: List[Path],
     modes: Optional[List[str]],
     verbose: bool,
     use_cache: bool = True,
     skip_version_check: bool = False,
     stdout_only: bool = False,
     disassemble_all: bool = False,
+    make_full_disasm_for_code=False,
 ):
     if stdout_only:
         progress_bar.out_file = sys.stdout
 
     # Load config
     global config
-    config = initialize_config(config_path, modes, verbose, disassemble_all)
+    config = conf.load(
+        config_path,
+        modes,
+        verbose,
+        disassemble_all,
+        make_full_disasm_for_code,
+    )
 
     disassembler_instance.create_disassembler_instance(skip_version_check, __version__)
 
@@ -565,7 +521,10 @@ def main(
 
 def add_arguments_to_parser(parser: argparse.ArgumentParser):
     parser.add_argument(
-        "config", help="path to a compatible config .yaml file", nargs="+"
+        "config",
+        help="path to a compatible config .yaml file",
+        nargs="+",
+        type=Path,
     )
     parser.add_argument("--modes", nargs="+", default="all")
     parser.add_argument("--verbose", action="store_true", help="Enable debug logging")
@@ -585,6 +544,11 @@ def add_arguments_to_parser(parser: argparse.ArgumentParser):
         help="Disasemble matched functions and migrated data",
         action="store_true",
     )
+    parser.add_argument(
+        "--make-full-disasm-for-code",
+        help="Emit a full `.s` file for each `c`/`cpp` segment besides the generated `nonmatchings` individual functions",
+        action="store_true",
+    )
 
 
 def process_arguments(args: argparse.Namespace):
@@ -596,6 +560,7 @@ def process_arguments(args: argparse.Namespace):
         args.skip_version_check,
         args.stdout_only,
         args.disassemble_all,
+        args.make_full_disasm_for_code,
     )
 
 

splat/segtypes/common/asm.py

@@ -14,9 +14,6 @@ class CommonSegAsm(CommonSegCodeSubsegment):
     def get_section_flags(self) -> Optional[str]:
         return "ax"
 
-    def out_path(self) -> Optional[Path]:
-        return options.opts.asm_path / self.dir / f"{self.name}.s"
-
     def scan(self, rom_bytes: bytes):
         if (
             self.rom_start is not None
@@ -25,35 +22,8 @@ class CommonSegAsm(CommonSegCodeSubsegment):
         ):
             self.scan_code(rom_bytes)
 
-    def get_file_header(self) -> List[str]:
-        ret = []
-
-        ret.append('.include "macro.inc"')
-        ret.append("")
-        ret.append(".set noat")  # allow manual use of $at
-        ret.append(".set noreorder")  # don't insert nops after branches
-        if options.opts.add_set_gp_64:
-            ret.append(".set gp=64")  # allow use of 64-bit general purpose registers
-        ret.append("")
-        preamble = options.opts.generated_s_preamble
-        if preamble:
-            ret.append(preamble)
-            ret.append("")
-
-        ret.append(self.get_section_asm_line())
-        ret.append("")
-
-        return ret
-
     def split(self, rom_bytes: bytes):
-        if not self.rom_start == self.rom_end and self.spim_section is not None:
-            out_path = self.out_path()
-            if out_path:
-                out_path.parent.mkdir(parents=True, exist_ok=True)
-
-                self.print_file_boundaries()
+        if self.rom_start == self.rom_end:
+            return
 
-                with open(out_path, "w", newline="\n") as f:
-                    for line in self.get_file_header():
-                        f.write(line + "\n")
-                    f.write(self.spim_section.disassemble())
+        self.split_as_asm_file(self.out_path())

splat/segtypes/common/asmtu.py

@@ -24,7 +24,7 @@ class CommonSegAsmtu(CommonSegAsm):
 
         with open(out_path, "w", newline="\n") as f:
             # Write `.text` contents
-            for line in self.get_file_header():
+            for line in self.get_asm_file_header():
                 f.write(line + "\n")
             f.write(self.spim_section.disassemble())
 
@@ -40,7 +40,7 @@ class CommonSegAsmtu(CommonSegAsm):
                 if (
                     isinstance(sibling, CommonSegCodeSubsegment)
                     and sibling.spim_section is not None
-                    and not sibling.should_split()
+                    and not sibling.should_self_split()
                 ):
                     f.write("\n")
                     f.write(f"{sibling.get_section_asm_line()}\n\n")
@@ -58,7 +58,7 @@ class CommonSegAsmtu(CommonSegAsm):
                 if (
                     isinstance(sibling, CommonSegCodeSubsegment)
                     and sibling.spim_section is not None
-                    and not sibling.should_split()
+                    and not sibling.should_self_split()
                 ):
                     f.write("\n")
                     f.write(f"{sibling.get_section_asm_line()}\n\n")

splat/segtypes/common/bss.py

@@ -60,7 +60,9 @@ class CommonSegBss(CommonSegData):
                 f"Segment '{self.name}' (type '{self.type}') requires a vram address. Got '{self.vram_start}'"
             )
 
-        next_subsegment = self.parent.get_next_subsegment_for_ram(self.vram_start)
+        next_subsegment = self.parent.get_next_subsegment_for_ram(
+            self.vram_start, self.index_within_group
+        )
         if next_subsegment is None:
             bss_end = self.get_most_parent().vram_end
         else:

splat/segtypes/common/c.py

@@ -276,6 +276,14 @@ class CommonSegC(CommonSegCodeSubsegment):
                                 spim_rodata_sym, asm_out_dir, rodata_sym
                             )
 
+            if options.opts.make_full_disasm_for_code:
+                # Disable gpRelHack since this file is expected to be built with modern gas
+                section = self.spim_section.get_section()
+                old_value = section.getGpRelHack()
+                section.setGpRelHack(False)
+                self.split_as_asm_file(self.asm_out_path())
+                section.setGpRelHack(old_value)
+
     def get_c_preamble(self):
         ret = []
 
@@ -380,13 +388,16 @@ class CommonSegC(CommonSegCodeSubsegment):
             # IDO uses the asm processor to embeed assembly, and it doesn't require a special directive to include symbols
             asm_outpath = asm_out_dir / self.name / f"{sym.filename}.s"
             rel_asm_outpath = os.path.relpath(asm_outpath, options.opts.base_path)
-            return f'#pragma GLOBAL_ASM("{rel_asm_outpath}")'
+            final_path = Path(rel_asm_outpath).as_posix()
+            return f'#pragma GLOBAL_ASM("{final_path}")'
 
         if options.opts.use_legacy_include_asm:
             rel_asm_out_dir = asm_out_dir.relative_to(options.opts.nonmatchings_path)
-            return f'{macro_name}(const s32, "{rel_asm_out_dir / self.name}", {sym.filename});'
+            final_path = (rel_asm_out_dir / self.name).as_posix()
+            return f'{macro_name}(const s32, "{final_path}", {sym.filename});'
 
-        return f'{macro_name}("{asm_out_dir / self.name}", {sym.filename});'
+        final_path = (asm_out_dir / self.name).as_posix()
+        return f'{macro_name}("{final_path}", {sym.filename});'
 
     def get_c_lines_for_function(
         self,
@@ -448,7 +459,7 @@ class CommonSegC(CommonSegCodeSubsegment):
                     c_lines += self.get_c_lines_for_rodata_sym(rodata_sym, asm_out_dir)
 
         c_path.parent.mkdir(parents=True, exist_ok=True)
-        with c_path.open("w") as f:
+        with c_path.open("w", newline=options.opts.c_newline) as f:
             f.write("\n".join(c_lines))
         log.write(f"Wrote {self.name} to {c_path}")
 
@@ -472,12 +483,12 @@ class CommonSegC(CommonSegCodeSubsegment):
 
         dep_path = build_path / c_path.with_suffix(".asmproc.d")
         dep_path.parent.mkdir(parents=True, exist_ok=True)
-        with dep_path.open("w") as f:
+        with dep_path.open("w", newline=options.opts.c_newline) as f:
             if options.opts.use_o_as_suffix:
                 o_path = build_path / c_path.with_suffix(".o")
             else:
                 o_path = build_path / c_path.with_suffix(c_path.suffix + ".o")
-            f.write(f"{o_path}:")
+            f.write(f"{o_path.as_posix()}:")
             depend_list = []
             for entry in symbols_entries:
                 if entry.function is not None:
@@ -488,7 +499,7 @@ class CommonSegC(CommonSegCodeSubsegment):
                         outpath.parent.mkdir(parents=True, exist_ok=True)
 
                         depend_list.append(outpath)
-                        f.write(f" \\\n    {outpath}")
+                        f.write(f" \\\n    {outpath.as_posix()}")
                 else:
                     for rodata_sym in entry.rodataSyms:
                         rodata_name = rodata_sym.getName()
@@ -498,9 +509,9 @@ class CommonSegC(CommonSegCodeSubsegment):
                             outpath.parent.mkdir(parents=True, exist_ok=True)
 
                             depend_list.append(outpath)
-                            f.write(f" \\\n    {outpath}")
+                            f.write(f" \\\n    {outpath.as_posix()}")
 
             f.write("\n")
 
             for depend_file in depend_list:
-                f.write(f"{depend_file}:\n")
+                f.write(f"{depend_file.as_posix()}:\n")

splat/segtypes/common/code.py

@@ -270,6 +270,8 @@ class CommonSegCode(CommonSegGroup):
                 sibling.siblings[segment.get_linker_section_linksection()] = segment
 
         ret = self._insert_all_auto_sections(ret, base_segments, readonly_before)
+        for i, seg in enumerate(ret):
+            seg.index_within_group = i
 
         return ret
 

splat/segtypes/common/codesubsegment.py

@@ -1,4 +1,5 @@
-from typing import Optional
+from pathlib import Path
+from typing import Optional, List
 
 import spimdisasm
 import rabbitizer
@@ -60,7 +61,7 @@ class CommonSegCodeSubsegment(Segment):
         section.isHandwritten = self.is_hasm
         section.instrCat = self.instr_category
         section.detectRedundantFunctionEnd = self.detect_redundant_function_end
-        section.gpRelHack = not self.use_gp_rel_macro
+        section.setGpRelHack(not self.use_gp_rel_macro)
 
     def scan_code(self, rom_bytes, is_hasm=False):
         self.is_hasm = is_hasm
@@ -194,3 +195,55 @@ class CommonSegCodeSubsegment(Segment):
         return (
             self.extract and options.opts.is_mode_active("code") and self.should_scan()
         )  # only split if the segment was scanned first
+
+    def should_self_split(self) -> bool:
+        return self.should_split()
+
+    def get_asm_file_header(self) -> List[str]:
+        ret = []
+
+        ret.append('.include "macro.inc"')
+        ret.append("")
+
+        ret.extend(self.get_asm_file_extra_directives())
+
+        preamble = options.opts.generated_s_preamble
+        if preamble:
+            ret.append(preamble)
+            ret.append("")
+
+        ret.append(self.get_section_asm_line())
+        ret.append("")
+
+        return ret
+
+    def get_asm_file_extra_directives(self) -> List[str]:
+        ret = []
+
+        ret.append(".set noat")  # allow manual use of $at
+        ret.append(".set noreorder")  # don't insert nops after branches
+        if options.opts.add_set_gp_64:
+            ret.append(".set gp=64")  # allow use of 64-bit general purpose registers
+        ret.append("")
+
+        return ret
+
+    def asm_out_path(self) -> Path:
+        return options.opts.asm_path / self.dir / f"{self.name}.s"
+
+    def out_path(self) -> Optional[Path]:
+        return self.asm_out_path()
+
+    def split_as_asm_file(self, out_path: Optional[Path]):
+        if self.spim_section is None:
+            return
+
+        if out_path:
+            out_path.parent.mkdir(parents=True, exist_ok=True)
+
+            self.print_file_boundaries()
+
+            with open(out_path, "w", newline="\n") as f:
+                for line in self.get_asm_file_header():
+                    f.write(line + "\n")
+                f.write(self.spim_section.disassemble())

splat/segtypes/common/data.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Optional
+from typing import Optional, List
 from ...util import options, symbols, log
 
 from .codesubsegment import CommonSegCodeSubsegment
@@ -38,33 +38,21 @@ class CommonSegData(CommonSegCodeSubsegment, CommonSegGroup):
         if self.rom_start is not None and self.rom_end is not None:
             self.disassemble_data(rom_bytes)
 
+    def get_asm_file_extra_directives(self) -> List[str]:
+        return []
+
     def split(self, rom_bytes: bytes):
         super().split(rom_bytes)
 
-        if self.type.startswith(".") and not options.opts.disassemble_all:
-            return
-
         if self.spim_section is None or not self.should_self_split():
             return
 
-        path = self.asm_out_path()
-
-        path.parent.mkdir(parents=True, exist_ok=True)
-
-        self.print_file_boundaries()
-
-        with path.open("w", newline="\n") as f:
-            f.write('.include "macro.inc"\n\n')
-            preamble = options.opts.generated_s_preamble
-            if preamble:
-                f.write(preamble + "\n")
-
-            f.write(f"{self.get_section_asm_line()}\n\n")
-
-            f.write(self.spim_section.disassemble())
+        self.split_as_asm_file(self.asm_out_path())
 
     def should_self_split(self) -> bool:
-        return options.opts.is_mode_active("data")
+        return options.opts.is_mode_active("data") and (
+            not self.type.startswith(".") or options.opts.disassemble_all
+        )
 
     def should_scan(self) -> bool:
         return True

splat/segtypes/common/group.py

@@ -110,11 +110,16 @@ class CommonSegGroup(CommonSegment):
                 self.special_vram_segment = True
             segment.is_auto_segment = is_auto_segment
 
+            segment.index_within_group = len(ret)
+
             ret.append(segment)
             prev_start = start
             if end is not None:
                 last_rom_end = end
 
+        for i, seg in enumerate(ret):
+            seg.index_within_group = i
+
         return ret
 
     @property
@@ -165,13 +170,17 @@ class CommonSegGroup(CommonSegment):
                 return sub
         return None
 
-    def get_next_subsegment_for_ram(self, addr: int) -> Optional[Segment]:
+    def get_next_subsegment_for_ram(
+        self, addr: int, current_subseg_index: Optional[int]
+    ) -> Optional[Segment]:
         """
         Returns the first subsegment which comes after the specified address,
         or None in case this address belongs to the last subsegment of this group
         """
 
-        for sub in self.subsegments:
+        start = current_subseg_index if current_subseg_index is not None else 0
+
+        for sub in self.subsegments[start:]:
             if sub.vram_start is None:
                 continue
             assert isinstance(sub.vram_start, int)

splat/segtypes/common/hasm.py

@@ -1,5 +1,4 @@
 from pathlib import Path
-from typing import Optional
 
 from .asm import CommonSegAsm
 
@@ -7,11 +6,11 @@ from ...util import options
 
 
 class CommonSegHasm(CommonSegAsm):
-    def out_path(self) -> Optional[Path]:
+    def asm_out_path(self) -> Path:
         if options.opts.hasm_in_src_path:
             return options.opts.src_path / self.dir / f"{self.name}.s"
 
-        return super().out_path()
+        return super().asm_out_path()
 
     def scan(self, rom_bytes: bytes):
         if (
@@ -22,14 +21,7 @@ class CommonSegHasm(CommonSegAsm):
             self.scan_code(rom_bytes, is_hasm=True)
 
     def split(self, rom_bytes: bytes):
-        if not self.rom_start == self.rom_end and self.spim_section is not None:
-            out_path = self.out_path()
-            if out_path and not out_path.exists():
-                out_path.parent.mkdir(parents=True, exist_ok=True)
+        if self.rom_start == self.rom_end:
+            return
 
-                self.print_file_boundaries()
-
-                with open(out_path, "w", newline="\n") as f:
-                    for line in self.get_file_header():
-                        f.write(line + "\n")
-                    f.write(self.spim_section.disassemble())
+        self.split_as_asm_file(self.out_path())

splat/segtypes/common/textbin.py

@@ -83,9 +83,13 @@ class CommonSegTextbin(CommonSegment):
 
         if sym is not None:
             f.write(f"{asm_label} {sym.name}\n")
+            if asm_label == ".globl":
+                if self.is_text():
+                    f.write(f".ent {sym.name}\n")
+                f.write(f"{sym.name}:\n")
             sym.defined = True
 
-        f.write(f'.incbin "{binpath}"\n')
+        f.write(f'.incbin "{binpath.as_posix()}"\n')
 
         if sym is not None:
             if self.is_text() and options.opts.asm_end_label != "":
@@ -97,6 +101,8 @@ class CommonSegTextbin(CommonSegment):
                     or sym.given_size == self.rom_end - self.rom_start
                 ):
                     f.write(f"{asm_label} {sym.given_name_end}\n")
+                    if asm_label == ".globl":
+                        f.write(f"{sym.given_name_end}:\n")
 
     def split(self, rom_bytes):
         if self.rom_end is None:

splat/segtypes/linker_entry.py

@@ -51,7 +51,7 @@ def write_file_if_different(path: Path, new_content: str):
 
     if old_content != new_content:
         path.parent.mkdir(parents=True, exist_ok=True)
-        with path.open("w") as f:
+        with path.open("w", newline=options.opts.c_newline) as f:
             f.write(new_content)
 
 
@@ -522,18 +522,18 @@ class LinkerWriter:
             )
 
     def save_dependencies_file(self, output_path: Path, target_elf_path: Path):
-        output = f"{target_elf_path}:"
+        output = f"{target_elf_path.as_posix()}:"
 
         for entry in self.dependencies_entries:
             if entry.object_path is None:
                 continue
-            output += f" \\\n    {entry.object_path}"
+            output += f" \\\n    {entry.object_path.as_posix()}"
 
         output += "\n"
         for entry in self.dependencies_entries:
             if entry.object_path is None:
                 continue
-            output += f"{entry.object_path}:\n"
+            output += f"{entry.object_path.as_posix()}:\n"
         write_file_if_different(output_path, output)
 
     def _writeln(self, line: str):
@@ -561,7 +561,7 @@ class LinkerWriter:
         self.header_symbols.add(symbol)
 
     def _write_object_path_section(self, object_path: Path, section: str):
-        self._writeln(f"{object_path}({section});")
+        self._writeln(f"{object_path.as_posix()}({section});")
 
     def _begin_segment(
         self, segment: Segment, seg_name: str, noload: bool, is_first: bool

splat/segtypes/segment.py

@@ -255,7 +255,7 @@ class Segment:
 
     @staticmethod
     def parse_suggestion_rodata_section_start(
-        yaml: Union[dict, list]
+        yaml: Union[dict, list],
     ) -> Optional[bool]:
         if isinstance(yaml, dict):
             suggestion_rodata_section_start = yaml.get(
@@ -354,6 +354,8 @@ class Segment:
         # Is an automatic segment, generated automatically or declared on the yaml by the user
         self.is_auto_segment: bool = False
 
+        self.index_within_group: Optional[int] = None
+
         if self.rom_start is not None and self.rom_end is not None:
             if self.rom_start > self.rom_end:
                 log.error(

splat/util/compiler.py

@@ -26,6 +26,7 @@ GCC = Compiler(
 SN64 = Compiler(
     "SN64",
     asm_function_macro=".globl",
+    asm_function_alt_macro=".globl",
     asm_jtbl_label_macro=".globl",
     asm_data_macro=".globl",
     asm_end_label=".end",

splat/util/conf.py

@@ -0,0 +1,96 @@
+"""
+This module is used to load splat configuration from a YAML file.
+
+A config dict can be loaded using `load`.
+
+    config = conf.load("path/to/splat.yaml")
+"""
+
+from typing import Any, Dict, List, Optional
+from pathlib import Path
+
+# This unused import makes the yaml library faster. don't remove
+import pylibyaml  # pyright: ignore
+import yaml
+
+from . import log, options, vram_classes
+
+
+def _merge_configs(main_config, additional_config, additional_config_path):
+    # Merge rules are simple
+    # For each key in the dictionary
+    # - If list then append to list
+    # - If a dictionary then repeat merge on sub dictionary entries
+    # - Else assume string or number and replace entry
+
+    for curkey in additional_config:
+        if curkey not in main_config:
+            main_config[curkey] = additional_config[curkey]
+        elif type(main_config[curkey]) != type(additional_config[curkey]):
+            raise TypeError(
+                f"Could not merge {str(additional_config_path)}: type for key '{curkey}' in configs does not match"
+            )
+        else:
+            # keys exist and match, see if a list to append
+            if type(main_config[curkey]) == list:
+                main_config[curkey] += additional_config[curkey]
+            elif type(main_config[curkey]) == dict:
+                # need to merge sub areas
+                main_config[curkey] = _merge_configs(
+                    main_config[curkey],
+                    additional_config[curkey],
+                    additional_config_path,
+                )
+            else:
+                # not a list or dictionary, must be a number or string, overwrite
+                main_config[curkey] = additional_config[curkey]
+
+    return main_config
+
+
+def load(
+    config_path: List[Path],
+    modes: Optional[List[str]] = None,
+    verbose: bool = False,
+    disassemble_all: bool = False,
+    make_full_disasm_for_code=False,
+) -> Dict[str, Any]:
+    """
+    Returns a `dict` with resolved splat config.
+
+    Multiple configuration files can be passed in ``config_path`` with each subsequent file merged into the previous.
+
+    `modes` specifies which modes are active (all, code, img, gfx, vtx, etc.). The default is all.
+
+    `verbose` may be used to determine whether or not to display additional output.
+
+    `disassemble_all` determines whether functions which are already compiled will be disassembled. This is OR-ed with
+    the `disassemble_all` key in a config file, if present.
+
+    After all files are merged, static validation is done on the configuration.
+
+    The returned `dict` represents the merged and validated YAML config.
+
+    As a side effect, the global `splat.util.options.opts` is set.
+
+    Config with invalid options may raise an error.
+    """
+
+    config: Dict[str, Any] = {}
+    for entry in config_path:
+        with entry.open() as f:
+            additional_config = yaml.load(f.read(), Loader=yaml.SafeLoader)
+        config = _merge_configs(config, additional_config, entry)
+
+    vram_classes.initialize(config.get("vram_classes"))
+
+    options.initialize(
+        config,
+        config_path,
+        modes,
+        verbose,
+        disassemble_all,
+        make_full_disasm_for_code,
+    )
+
+    return config

splat/util/options.py

@@ -220,6 +220,8 @@ class SplatOpts:
     detect_redundant_function_end: bool
     # Don't skip disassembling already matched functions and migrated sections
     disassemble_all: bool
+    # Emit a full `.s` file for each `c`/`cpp` segment besides the generated `nonmatchings` individual functions
+    make_full_disasm_for_code: bool
     # Allow specifying that the global memory range may be larger than what was automatically detected.
     # Useful for projects where splat is used in multiple individual files, meaning the expected global segment may not be properly detected because each instance of splat can't see the info from other files.
     global_vram_start: Optional[int]
@@ -344,10 +346,11 @@ class OptParser:
 
 def _parse_yaml(
     yaml: Dict,
-    config_paths: List[str],
+    config_paths: List[Path],
     modes: List[str],
     verbose: bool = False,
     disasm_all: bool = False,
+    make_full_disasm_for_code: bool = False,
 ) -> SplatOpts:
     p = OptParser(yaml)
 
@@ -356,7 +359,7 @@ def _parse_yaml(
     comp = compiler.for_name(p.parse_opt("compiler", str, "IDO"))
 
     base_path = Path(
-        os.path.normpath(Path(config_paths[0]).parent / p.parse_opt("base_path", str))
+        os.path.normpath(config_paths[0].parent / p.parse_opt("base_path", str))
     )
     asm_path: Path = p.parse_path(base_path, "asm_path", "asm")
 
@@ -554,10 +557,12 @@ def _parse_yaml(
         detect_redundant_function_end=p.parse_opt(
             "detect_redundant_function_end", bool, True
         ),
-        # Command line argument takes precedence over yaml option
-        disassemble_all=(
-            disasm_all if disasm_all else p.parse_opt("disassemble_all", bool, False)
-        ),
+        # Setting either option will produce a full disassembly,
+        # but we still have to check the yaml option first to avoid leaving option unparsed,
+        # because splat would complain about an unrecognized yaml option otherwise.
+        disassemble_all=p.parse_opt("disassemble_all", bool, False) or disasm_all,
+        make_full_disasm_for_code=p.parse_opt("make_full_disasm_for_code", bool, False)
+        or make_full_disasm_for_code,
         global_vram_start=p.parse_optional_opt("global_vram_start", int),
         global_vram_end=p.parse_optional_opt("global_vram_end", int),
         use_gp_rel_macro_nonmatching=p.parse_opt(
@@ -574,14 +579,22 @@ def _parse_yaml(
 
 def initialize(
     config: Dict,
-    config_paths: List[str],
+    config_paths: List[Path],
     modes: Optional[List[str]] = None,
     verbose=False,
     disasm_all=False,
+    make_full_disasm_for_code=False,
 ):
     global opts
 
     if not modes:
         modes = ["all"]
 
-    opts = _parse_yaml(config["options"], config_paths, modes, verbose, disasm_all)
+    opts = _parse_yaml(
+        config["options"],
+        config_paths,
+        modes,
+        verbose,
+        disasm_all,
+        make_full_disasm_for_code,
+    )

{splat64-0.32.2.dist-info → splat64-0.33.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splat64
-Version: 0.32.2
+Version: 0.33.0
 Summary: A binary splitting tool to assist with decompilation and modding projects
 Project-URL: Repository, https://github.com/ethteck/splat
 Project-URL: Issues, https://github.com/ethteck/splat/issues
@@ -76,7 +76,7 @@ The brackets corresponds to the optional dependencies to install while installin
 If you use a `requirements.txt` file in your repository, then you can add this library with the following line:
 
 ```txt
-splat64[mips]>=0.32.2,<1.0.0
+splat64[mips]>=0.33.0,<1.0.0
 ```
 
 ### Optional dependencies

{splat64-0.32.2.dist-info → splat64-0.33.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-splat/__init__.py,sha256=a-EuQ-1jQ9RLrnfrNmIp7R4dCc2ShUTZv0j4car-jHI,291
+splat/__init__.py,sha256=BC3Ztd-mFegTEbtIJhxdClCWjIA8qw5qhS8jZNWQ-ec,291
 splat/__main__.py,sha256=T333dHDgr-2HYYhtARnYMEjdECnYiNIKfcXDD99o22A,732
 splat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 splat/disassembler/__init__.py,sha256=IubLMnm_F5cZ7WUPBfk1VJ7vdj6i1if5GG6RBvEoBEA,226
@@ -6,7 +6,7 @@ splat/disassembler/disassembler.py,sha256=2ynehZRz1P6UnaBk6DWRy4c3ynRnnWApMhf0K9
 splat/disassembler/disassembler_instance.py,sha256=09GW7QYoNolgE2wnO7ALngw_CxgF-mfyLiXBsyv22jA,916
 splat/disassembler/disassembler_section.py,sha256=J9jtplQVDVeGBmyEOcMpC3Hv3DyecqaNjlYc7zqEqDI,7459
 splat/disassembler/null_disassembler.py,sha256=jYuDMtfPiBifwz0H-ZHLMWtpGa19X_iLgy4K-dQhPYY,328
-splat/disassembler/spimdisasm_disassembler.py,sha256=Z3eLbmO1Q7uY9zdbFzGJH1zE1LgHSLRQWRwyYpNFuzQ,5685
+splat/disassembler/spimdisasm_disassembler.py,sha256=Lj6zp2g7Jo4sRlZ7CavLb7qM4alzEG1n7AhFYLiskqU,5685
 splat/platforms/__init__.py,sha256=qjqKi63k5N3DUdILNfuk6qpJJkVeAWpjAs36L97vvP4,100
 splat/platforms/n64.py,sha256=kgWr6nesGC0X-qVydmu8tSq48NbqVf9mF6EyqvUuoUM,421
 splat/platforms/ps2.py,sha256=QI_8Ve43LZeNqpuk8_CFxIqsNJpMTacRHXdZVh3iY6c,336
@@ -15,25 +15,25 @@ splat/platforms/psx.py,sha256=YxQERdOBr4p3ab9Wk80FNhVYi-uvmh7p_jeykSFp23M,40
 splat/scripts/__init__.py,sha256=OY0nHg6a7JB437Sb96qLbZ_7ByVsal1gStj35wJAI_Y,101
 splat/scripts/capy.py,sha256=svbOfLO34-QN3xLiBy9vk2RGs_To8TWMWEKBw6yx2xQ,3674
 splat/scripts/create_config.py,sha256=nFwIt1UWzlWE9C3i-2dGsVyGX2cuXzIqkp2kur2-pdE,7670
-splat/scripts/split.py,sha256=INZ8gwyv9ulSfrNYJuPykkg5BWWsYLnto6JVXXIiHG0,20704
+splat/scripts/split.py,sha256=EJLpvwGurQZEe-FE3hfNcMFIbxLToB4SX95OXdL_qoE,19285
 splat/segtypes/__init__.py,sha256=-upUw_4JGQtvyp6IfTMzOq_CK3xvVaT_0K0_EipHyOo,208
-splat/segtypes/linker_entry.py,sha256=m2qrZEZaRqsurUVlgo5rQt-4OZwDywK8hTqY1SoF2D8,24689
-splat/segtypes/segment.py,sha256=Ey4d4hxGWL4e8ZsxVRGXafP9GCFXB-3F6loaBFVDU-k,28764
+splat/segtypes/linker_entry.py,sha256=e2IzjAWC1B_JCx5pxBdKJrzOCse4SYUBrLHM8l3AR3o,24765
+splat/segtypes/segment.py,sha256=Y8OaNle09VeQ8pghzMQtxu8I2sWKy8fWPdfRH1zkUXU,28820
 splat/segtypes/common/__init__.py,sha256=mnq0acScilSCCo6q2PvkDk0Or3V8qitA7I8QMVw8haI,631
-splat/segtypes/common/asm.py,sha256=_EfIbDOlQdmvAVqPq_Jxgp335zIxEPLnuQc96x9EyOY,1819
-splat/segtypes/common/asmtu.py,sha256=hrflvDGZ4BcVEA8CRkkIOlqt0tUCC4iNb4oclht2o6s,2274
+splat/segtypes/common/asm.py,sha256=k3p4vgbQJP40iyTgQkIci1j3CpKkWksqoWBx2Pb2oh8,703
+splat/segtypes/common/asmtu.py,sha256=5FOVAXjqhM-kynm-nOuS1k7E9048WAW2eNHdKYtR5m8,2288
 splat/segtypes/common/bin.py,sha256=6rxYRXTdAVEs3AFMgmhelOwOmKMg3bbkl-j4k4wqql4,1229
-splat/segtypes/common/bss.py,sha256=EIN8E7CfqwcWRMWb_JIbGBicu6VKREdIbvQZNBM-6sM,3037
-splat/segtypes/common/c.py,sha256=NWLc1ArOQ3t2xfIJj8I2AGzm8xNR9DPbb5Wgg9L1VNY,19755
-splat/segtypes/common/code.py,sha256=23VZJXNFi3PYq3xH269DlxjCiqasSQnMuxwQkh-1qXU,10629
-splat/segtypes/common/codesubsegment.py,sha256=fRDFUu9RzBSMeHo_vsT0Ko1qoeLDq8kLaIX4asJGMa4,7015
+splat/segtypes/common/bss.py,sha256=nktRbKrDivweyLdsUQkL5guSayqpwn7NK5j3gq3arKc,3084
+splat/segtypes/common/c.py,sha256=FBcEQ6GB5-F5wZQCahh2FjkqLkWFHBTehql8SuLVQyY,20419
+splat/segtypes/common/code.py,sha256=CFDbn2YCoRIpUT07vTW0rUQtG58X0sxTtp17VPbrZsc,10706
+splat/segtypes/common/codesubsegment.py,sha256=_fpQF7O5pq4CBclhqcR4_KbiY8Oo2p7gaMEnkICBfQ4,8558
 splat/segtypes/common/cpp.py,sha256=p-duowCt4czrmaWgj1LuFw5LGfdyB_uaeLTKVmH80Cg,180
-splat/segtypes/common/data.py,sha256=ZR6ZVgAOWuKJOMpKAe4nK2ORH9oAjQ8uSszcTJaZ1j8,5997
+splat/segtypes/common/data.py,sha256=r9G_vYieNlRze-5wGOKFazvFjpuodfSLad6iCNsBOAU,5665
 splat/segtypes/common/databin.py,sha256=ucbbsc_M1332KifjExuDsf1wqm4-GZAiLqOwwrUwUpQ,1194
 splat/segtypes/common/eh_frame.py,sha256=MzL373ej2E38leM47py3T5beLq2IolsYszLZM8PYS2Y,913
 splat/segtypes/common/gcc_except_table.py,sha256=-ZrQL5dCcRu7EPFFPgL8lIJwWL5FsEeeQoSUVfTkyIg,2112
-splat/segtypes/common/group.py,sha256=DIDLeiOlpguIPatw8a9vHmvsQ2LXI-QWbFy_D7PhVgQ,5928
-splat/segtypes/common/hasm.py,sha256=HW6OADo-2D3Jln0q5KAoE8zUGOUiJAUEHqHOG4dRmw8,1130
+splat/segtypes/common/group.py,sha256=4g8jrpUjlsvxFuFRauS4rdxTvAAePebc941fQj96qEA,6197
+splat/segtypes/common/hasm.py,sha256=0sU00X0Ax-DK2y8-lKt1ZowjaVKX-5bdiKnjnX_cKGA,703
 splat/segtypes/common/header.py,sha256=NspQdk-L69j9dOBzBtDKb7bc11Gwa0WDWIVCd2P4mfE,1257
 splat/segtypes/common/lib.py,sha256=WaJH0DH0B8iJvhYQWYBjThbNeEXz3Yh7E8ZyONe5JtQ,2349
 splat/segtypes/common/linker_offset.py,sha256=IaEXMXq62BS2g95I4lS0wax5Ehjfi3O3C-uSDUbMjvI,767
@@ -44,7 +44,7 @@ splat/segtypes/common/rodatabin.py,sha256=uqp60QuwHwvlMwHq0nZrU3y3yYcHbv2twT0PID
 splat/segtypes/common/sbss.py,sha256=blIEuVYie4qNEOYMmlSdltn5f4MvgJu3AV8vqVD8Nh4,131
 splat/segtypes/common/sdata.py,sha256=dnLzNSNtSyclLZiNUmFTv0e0BWN8glxB1km1MSRq6xY,136
 splat/segtypes/common/segment.py,sha256=vVFyFjs-gS5qIWO8Pd0pMJYxboP-iBRKvxcDV8YxdYM,94
-splat/segtypes/common/textbin.py,sha256=6WXGaAPJhqFYamqoUPeSr2nq2M6Go3BxG1_s7UozEUA,4296
+splat/segtypes/common/textbin.py,sha256=Xj-PxEDTN8f0DLgdZ2uA26SYCcXD3rqqr2r6-pEiA4Y,4578
 splat/segtypes/n64/__init__.py,sha256=tf2yWlijeKmOp1OhEEL-aW88mU-mWQRC2lSjQ5Ww1eI,569
 splat/segtypes/n64/ci.py,sha256=An7wIHcoZ89KiGCKpCRbM7IrmDNYBidXT-6kjKn2vH0,2400
 splat/segtypes/n64/ci4.py,sha256=ZP8e12CpV8U7r8oLnb9uHc-MkmBbxjXBbJxROFvOjiM,184
@@ -78,9 +78,10 @@ splat/segtypes/psx/header.py,sha256=2S8XG_6zfLGzmEA0XpFqs0-4nf52YD9Erk6SbMUlVzo,
 splat/util/__init__.py,sha256=3-jgYUssL84IgaR_JF1hSb-lN4ru0gJQTrjP_UGEWu8,470
 splat/util/cache_handler.py,sha256=N0SggmvYwh0k-0fngHXoHG1CosC2rCsnlCTDsG8z5aE,1852
 splat/util/color.py,sha256=FSmy0dAQJ9FzRBc99Yt4kBEyB62MC_YiVkqoWgPMsRU,371
-splat/util/compiler.py,sha256=g9MjVe6E1kSGRxgDRgWGEd4qdDf2LzGLK1QRtp4znMc,1493
+splat/util/compiler.py,sha256=xDDNdnutmkB7T21j-BccBMdkA2leU3GzXuTYEWgVgNw,1530
+splat/util/conf.py,sha256=aM6O2QikosjL95pCxI2FcCxrwDsLP8T8sRf2Uev_Pac,3236
 splat/util/log.py,sha256=GguW9AolH-EXGBmh-8aZXgUeBFJthqAOb3qKtRYUSj8,999
-splat/util/options.py,sha256=XrOq83KPdNU-RjrIMx-G6jZ8-y0wtsnazuuqcSaSWeY,28061
+splat/util/options.py,sha256=JHyZnBuB86tbZN_HvhAvOH8oZGsppIc9KmgRVRkBWvg,28632
 splat/util/palettes.py,sha256=d3KoZnwt-zunI9eNwb3txysXg4DY3xnF0O5aQRxM4so,2920
 splat/util/progress_bar.py,sha256=41VehpIFK1cphENaXV_Aq6_3mFx25eQ8V7Z51SKFPeM,166
 splat/util/relocs.py,sha256=cgQYSaAtNpLlUZQdhEfa7ZpI8i0HqoDhwB88QtFqdJs,4212
@@ -93,8 +94,8 @@ splat/util/n64/find_code_length.py,sha256=uUoPoUORAjsAvH8oGqwnGvw6j8I_NnSrZtA-x9
 splat/util/n64/rominfo.py,sha256=U6TieblUAmxhZsn7u8nbjOKkbC6ygsC_7IiLLaOWwUE,14646
 splat/util/psx/__init__.py,sha256=kCCaR-KB1mNlIcXB4OuuSQ2zVLbWg_SnIZIUeyjeBBI,39
 splat/util/psx/psxexeinfo.py,sha256=MrxY28nes0uzpFmCz0o9JFbF8s1eQRQNOpC_82wsMVI,5725
-splat64-0.32.2.dist-info/METADATA,sha256=yd7HFS__8mQ3lqO6kA14ZYdwImHBVTcQc0zdtOaGDYI,3830
-splat64-0.32.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-splat64-0.32.2.dist-info/entry_points.txt,sha256=O7Xy-qNOHcI87-OQrWJ-OhRDws74SuwVb_4rtnp0eLo,52
-splat64-0.32.2.dist-info/licenses/LICENSE,sha256=97VMVzjG8yQvsf8NG2M9IFSbh7R8cifJnc6QK1cZqj8,1070
-splat64-0.32.2.dist-info/RECORD,,
+splat64-0.33.0.dist-info/METADATA,sha256=5nOsSDJcmC7QQQzzzQGbGFjTCIT_xlq9q2AAgt04PhI,3830
+splat64-0.33.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+splat64-0.33.0.dist-info/entry_points.txt,sha256=O7Xy-qNOHcI87-OQrWJ-OhRDws74SuwVb_4rtnp0eLo,52
+splat64-0.33.0.dist-info/licenses/LICENSE,sha256=97VMVzjG8yQvsf8NG2M9IFSbh7R8cifJnc6QK1cZqj8,1070
+splat64-0.33.0.dist-info/RECORD,,