Update from dtk-template

configure.py

@@ -142,9 +142,9 @@
 # Tool versions
 config.binutils_tag = "2.42-1"
 config.compilers_tag = "20240706"
-config.dtk_tag = "v1.1.2"
-config.objdiff_tag = "v2.3.2"
-config.sjiswrap_tag = "v1.1.1"
+config.dtk_tag = "v1.3.0"
+config.objdiff_tag = "v2.4.0"
+config.sjiswrap_tag = "v1.2.0"
 config.wibo_tag = "0.6.11"
 
 # Project
@@ -172,6 +172,10 @@
 # Use for any additional files that should cause a re-configure when modified
 config.reconfig_deps = []
 
+# Optional numeric ID for decomp.me preset
+# Can be overridden in libraries or objects
+config.scratch_preset_id = None
+
 # Base flags, common to most GC/Wii games.
 # Generally leave untouched, with overrides added below.
 cflags_base = [
@@ -301,6 +305,12 @@ def nw4rLib(lib_name, objects, extra_cflags=[]):
     config.non_matching
 )  # Object should be linked when configured with --non-matching
 
+
+# Object is only matching for specific versions
+def MatchingFor(*versions):
+    return config.version in versions
+
+
 config.warn_missing_config = False
 config.warn_missing_source = False
 config.libs = [

src/d/d_heap.cpp

@@ -63,9 +63,7 @@ void dHeap::createLayoutEx2Heap(size_t size, EGG::Heap *parent) {
     layoutEx2Heap.init(name, size, parent);
 }
 void dHeap::createLayoutResHeap(size_t size, EGG::Heap *parent) {
-    // Supposed to be "レイアウトリソース用ヒープ(dHeap::layoutResHeap)" but
-    // this creates a Linux compile issue with wibo
-    static const char name[] = "レイアウトリ\x83\x5Cース用ヒープ(dHeap::layoutResHeap)";
+    static const char name[] = "レイアウトリソース用ヒープ(dHeap::layoutResHeap)";
     layoutResHeap.init(name, size, parent);
 }
 void dHeap::createFontHeap(size_t size, EGG::Heap *parent) {

src/m/m2d.cpp

@@ -27,8 +27,7 @@ bool init(mAllocator_c *allocator) {
 void create(EGG::Heap *heap, u32 size) {
     if (size != 0) {
         heap = EGG::ExpHeap::create(size, heap, 0);
-        // Supposed to be 2D表示用ヒープ(m2d::create), but creates a linux compile issue
-        heap->setName("2D\x95\x5C示用ヒープ(m2d::create)");
+        heap->setName("2D表示用ヒープ(m2d::create)");
     }
     mAllocator_c *allocator = new (heap, 0x04) mAllocator_c();
     allocator->attach(heap, 4);

tools/decompctx.py

@@ -18,84 +18,63 @@
 script_dir = os.path.dirname(os.path.realpath(__file__))
 root_dir = os.path.abspath(os.path.join(script_dir, ".."))
 src_dir = os.path.join(root_dir, "src")
-include_dirs = [
-    os.path.join(root_dir, "include"),
-    # Add additional include directories here
-    os.path.join(root_dir, "src"),
-    os.path.join(root_dir, "src", "PowerPC_EABI_Support", "MetroTRK"),
-    os.path.join(
-        root_dir, "src", "PowerPC_EABI_Support", "MSL", "MSL_C", "MSL_Common", "Include"
-    ),
-    os.path.join(
-        root_dir,
-        "src",
-        "PowerPC_EABI_Support",
-        "MSL",
-        "MSL_C",
-        "MSL_Common_Embedded",
-        "Math",
-        "Include",
-    ),
-    os.path.join(root_dir, "src", "PowerPC_EABI_Support", "MSL", "MSL_C", "PPC_EABI"),
-    os.path.join(
-        root_dir,
-        "src",
-        "PowerPC_EABI_Support",
-        "MSL",
-        "MSL_C++",
-        "MSL_Common",
-        "Include",
-    ),
-    os.path.join(root_dir, "src", "PowerPC_EABI_Support", "Runtime", "Inc"),
-]
+include_dirs: List[str] = []  # Set with -I flag
 
 include_pattern = re.compile(r'^#\s*include\s*[<"](.+?)[>"]')
 guard_pattern = re.compile(r"^#\s*ifndef\s+(.*)$")
+once_pattern = re.compile(r"^#\s*pragma\s+once$")
 
 defines = set()
+deps = []
 
 
-def import_h_file(in_file: str, r_path: str, deps: List[str]) -> str:
+def import_h_file(in_file: str, r_path: str) -> str:
     rel_path = os.path.join(root_dir, r_path, in_file)
     if os.path.exists(rel_path):
-        return import_c_file(rel_path, deps)
+        return import_c_file(rel_path)
     for include_dir in include_dirs:
         inc_path = os.path.join(include_dir, in_file)
         if os.path.exists(inc_path):
-            return import_c_file(inc_path, deps)
+            return import_c_file(inc_path)
     else:
         print("Failed to locate", in_file)
         return ""
 
 
-def import_c_file(in_file: str, deps: List[str]) -> str:
+def import_c_file(in_file: str) -> str:
     in_file = os.path.relpath(in_file, root_dir)
     deps.append(in_file)
     out_text = ""
 
     try:
         with open(in_file, encoding="utf-8") as file:
-            out_text += process_file(in_file, list(file), deps)
+            out_text += process_file(in_file, list(file))
     except Exception:
         with open(in_file) as file:
-            out_text += process_file(in_file, list(file), deps)
+            out_text += process_file(in_file, list(file))
     return out_text
 
 
-def process_file(in_file: str, lines: List[str], deps: List[str]) -> str:
+def process_file(in_file: str, lines: List[str]) -> str:
     out_text = ""
     for idx, line in enumerate(lines):
-        guard_match = guard_pattern.match(line.strip())
         if idx == 0:
+            guard_match = guard_pattern.match(line.strip())
             if guard_match:
                 if guard_match[1] in defines:
                     break
                 defines.add(guard_match[1])
+            else:
+                once_match = once_pattern.match(line.strip())
+                if once_match:
+                    if in_file in defines:
+                        break
+                    defines.add(in_file)
             print("Processing file", in_file)
         include_match = include_pattern.match(line.strip())
         if include_match and not include_match[1].endswith(".s"):
             out_text += f'/* "{in_file}" line {idx} "{include_match[1]}" */\n'
-            out_text += import_h_file(include_match[1], os.path.dirname(in_file), deps)
+            out_text += import_h_file(include_match[1], os.path.dirname(in_file))
             out_text += f'/* end "{include_match[1]}" */\n'
         else:
             out_text += line
@@ -126,10 +105,19 @@ def main():
         "--depfile",
         help="""Dependency file""",
     )
+    parser.add_argument(
+        "-I",
+        "--include",
+        help="""Include directory""",
+        action="append",
+    )
     args = parser.parse_args()
 
-    deps = []
-    output = import_c_file(args.c_file, deps)
+    if args.include is None:
+        exit("No include directories specified")
+    global include_dirs
+    include_dirs = args.include
+    output = import_c_file(args.c_file)
 
     with open(os.path.join(root_dir, args.output), "w", encoding="utf-8") as f:
         f.write(output)

tools/ninja_syntax.py

@@ -24,17 +24,10 @@
 import os
 from io import StringIO
 from pathlib import Path
-from typing import Dict, List, Match, Optional, Tuple, Union
+from typing import Dict, Iterable, List, Match, Optional, Tuple, Union
 
 NinjaPath = Union[str, Path]
-NinjaPaths = Union[
-    List[str],
-    List[Path],
-    List[NinjaPath],
-    List[Optional[str]],
-    List[Optional[Path]],
-    List[Optional[NinjaPath]],
-]
+NinjaPaths = Iterable[Optional[NinjaPath]]
 NinjaPathOrPaths = Union[NinjaPath, NinjaPaths]
 
 
@@ -118,8 +111,8 @@ def build(
         pool: Optional[str] = None,
         dyndep: Optional[NinjaPath] = None,
     ) -> List[str]:
-        outputs = serialize_paths(outputs)
-        out_outputs = [escape_path(x) for x in outputs]
+        str_outputs = serialize_paths(outputs)
+        out_outputs = [escape_path(x) for x in str_outputs]
         all_inputs = [escape_path(x) for x in serialize_paths(inputs)]
 
         if implicit:
@@ -154,7 +147,7 @@ def build(
             for key, val in iterator:
                 self.variable(key, val, indent=1)
 
-        return outputs
+        return str_outputs
 
     def include(self, path: str) -> None:
         self._line("include %s" % path)
@@ -225,9 +218,11 @@ def serialize_path(input: Optional[NinjaPath]) -> str:
 
 
 def serialize_paths(input: Optional[NinjaPathOrPaths]) -> List[str]:
-    if isinstance(input, list):
+    if isinstance(input, str) or isinstance(input, Path):
+        return [serialize_path(input)] if input else []
+    elif input is not None:
         return [serialize_path(path) for path in input if path]
-    return [serialize_path(input)] if input else []
+    return []
 
 
 def escape(string: str) -> str: