Merge pull request rizonesoft#5570 from RaiKoHoff/Dev_Master

chore: upd uthash, add timsort (repl. qsort)

Author: RaiKoHoff

.gitignore

@@ -8,6 +8,7 @@
 ehthumbs.db
 Thumbs.db
 .vscode
+.venv
 .agent
 
 # C++ Junk           #

Build/scripts/check_scicall.py

@@ -0,0 +1,386 @@
+#!/usr/bin/env python3
+"""
+check_scicall.py - Diff Scintilla.iface against SciCall.h
+
+Parses Scintilla.iface to find all fun/get/set messages and compares
+against SciCall.h to find:
+  1. iface messages NOT wrapped in SciCall.h (candidates to add)
+  2. SciCall.h wrappers that don't match any iface message (stale/custom)
+
+Usage:
+    python Build/scripts/check_scicall.py
+    python Build/scripts/check_scicall.py --verbose
+    python Build/scripts/check_scicall.py --category Basics
+    python Build/scripts/check_scicall.py --generate
+"""
+
+import argparse
+import os
+import re
+import sys
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+REPO_ROOT = os.path.normpath(os.path.join(SCRIPT_DIR, "..", ".."))
+
+IFACE_PATH = os.path.join(REPO_ROOT, "scintilla", "include", "Scintilla.iface")
+SCICALL_PATH = os.path.join(REPO_ROOT, "src", "SciCall.h")
+
+# iface type -> NP3 C type mapping
+TYPE_MAP = {
+    "void": "void",
+    "position": "DocPos",
+    "line": "DocLn",
+    "colour": "COLORREF",
+    "colouralpha": "COLORALPHAREF",
+    "bool": "bool",
+    "int": "int",
+    "string": "const char*",
+    "stringresult": "char*",
+    "pointer": "sptr_t",
+    "cells": "const char*",
+    "textrange": "struct Sci_TextRange*",
+    "textrangefull": "struct Sci_TextRangeFull*",
+    "findtext": "struct Sci_TextToFind*",
+    "findtextfull": "struct Sci_TextToFindFull*",
+    "formatrange": "struct Sci_RangeToFormat*",
+    "formatrangefull": "struct Sci_RangeToFormatFull*",
+    "keymod": "size_t",
+}
+
+
+def map_type(iface_type):
+    """Map an iface type to an NP3 C type."""
+    if iface_type in TYPE_MAP:
+        return TYPE_MAP[iface_type]
+    # Capitalized enum types -> int
+    if iface_type and iface_type[0].isupper():
+        return "int"
+    return "int"
+
+
+def parse_iface(path):
+    """Parse Scintilla.iface, returning a dict of uppercase_name -> info."""
+    messages = {}
+    current_category = "Unknown"
+
+    # Match: fun/get/set <rettype> <Name>=<number>(<params>)
+    msg_re = re.compile(
+        r"^(fun|get|set)\s+"       # feature type
+        r"(\S+)\s+"                # return type
+        r"(\w+)"                   # function name
+        r"=(\d+)"                  # message number
+        r"\(([^)]*)\)"             # parameters
+    )
+    cat_re = re.compile(r"^cat\s+(\w+)")
+
+    with open(path, "r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, 1):
+            line = line.rstrip()
+
+            cat_m = cat_re.match(line)
+            if cat_m:
+                current_category = cat_m.group(1)
+                continue
+
+            if line.startswith("##") or line.startswith("#!"):
+                continue
+
+            msg_m = msg_re.match(line)
+            if msg_m:
+                feat_type = msg_m.group(1)
+                ret_type = msg_m.group(2)
+                name = msg_m.group(3)
+                msg_num = int(msg_m.group(4))
+                params_str = msg_m.group(5).strip()
+                upper_name = name.upper()
+
+                messages[upper_name] = {
+                    "name": name,
+                    "upper": upper_name,
+                    "type": feat_type,
+                    "ret": ret_type,
+                    "num": msg_num,
+                    "params": params_str,
+                    "category": current_category,
+                    "line": line_no,
+                    "raw": line,
+                }
+
+    return messages
+
+
+def parse_scicall(path):
+    """Parse SciCall.h, returning a dict of uppercase_msg -> info."""
+    wrappers = {}
+
+    # Match: DeclareSciCall{R,V}{0,01,1,2}(fn, MSG, ...)
+    decl_re = re.compile(
+        r"DeclareSciCall([RV])(0|01|1|2)\s*\(\s*(\w+)\s*,\s*(\w+)"
+    )
+    # Also match commented-out declarations
+    commented_re = re.compile(
+        r"//~?\s*DeclareSciCall([RV])(0|01|1|2)\s*\(\s*(\w+)\s*,\s*(\w+)"
+    )
+
+    with open(path, "r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, 1):
+            line_stripped = line.rstrip()
+
+            # Skip macro definitions (#define DeclareSciCall...)
+            if line_stripped.startswith("#define"):
+                continue
+
+            # Check for commented-out declarations (track but mark)
+            cm = commented_re.match(line_stripped)
+            if cm:
+                upper_msg = cm.group(4)
+                wrappers[upper_msg] = {
+                    "fn": cm.group(3),
+                    "msg": upper_msg,
+                    "macro_ret": cm.group(1),
+                    "macro_params": cm.group(2),
+                    "line": line_no,
+                    "commented": True,
+                    "raw": line_stripped,
+                }
+                continue
+
+            dm = decl_re.search(line_stripped)
+            if dm:
+                upper_msg = dm.group(4)
+                wrappers[upper_msg] = {
+                    "fn": dm.group(3),
+                    "msg": upper_msg,
+                    "macro_ret": dm.group(1),
+                    "macro_params": dm.group(2),
+                    "line": line_no,
+                    "commented": False,
+                    "raw": line_stripped,
+                }
+
+    return wrappers
+
+
+def parse_param(param_str):
+    """Parse a single iface param like 'position pos' or '' into (type, name)."""
+    param_str = param_str.strip()
+    if not param_str:
+        return None, None
+    # Handle default values like 'int defaultValue'
+    parts = param_str.split()
+    if len(parts) >= 2:
+        return parts[0], parts[1].split("=")[0]
+    elif len(parts) == 1:
+        return parts[0], "param"
+    return None, None
+
+
+def generate_wrapper(msg):
+    """Generate a DeclareSciCall* line for an iface message."""
+    name = msg["name"]
+    upper = msg["upper"]
+    ret_type = msg["ret"]
+    params_str = msg["params"]
+
+    # Parse return type
+    c_ret = map_type(ret_type)
+    is_void = (ret_type == "void")
+
+    # Parse parameters
+    if "," in params_str:
+        wp_str, lp_str = params_str.split(",", 1)
+    else:
+        wp_str = params_str
+        lp_str = ""
+
+    wp_type, wp_name = parse_param(wp_str)
+    lp_type, lp_name = parse_param(lp_str)
+
+    has_wp = wp_type is not None
+    has_lp = lp_type is not None
+
+    # Determine macro variant
+    rv = "V" if is_void else "R"
+
+    if has_wp and has_lp:
+        variant = "2"
+    elif has_wp and not has_lp:
+        variant = "1"
+    elif not has_wp and has_lp:
+        variant = "01"
+    else:
+        variant = "0"
+
+    macro = f"DeclareSciCall{rv}{variant}"
+
+    # Build arguments
+    if variant == "0":
+        if is_void:
+            return f"{macro}({name}, {upper});"
+        else:
+            return f"{macro}({name}, {upper}, {c_ret});"
+    elif variant == "1":
+        c_wp = map_type(wp_type)
+        if is_void:
+            return f"{macro}({name}, {upper}, {c_wp}, {wp_name});"
+        else:
+            return f"{macro}({name}, {upper}, {c_ret}, {c_wp}, {wp_name});"
+    elif variant == "01":
+        c_lp = map_type(lp_type)
+        if is_void:
+            return f"{macro}({name}, {upper}, {c_lp}, {lp_name});"
+        else:
+            return f"{macro}({name}, {upper}, {c_ret}, {c_lp}, {lp_name});"
+    elif variant == "2":
+        c_wp = map_type(wp_type)
+        c_lp = map_type(lp_type)
+        if is_void:
+            return f"{macro}({name}, {upper}, {c_wp}, {wp_name}, {c_lp}, {lp_name});"
+        else:
+            return f"{macro}({name}, {upper}, {c_ret}, {c_wp}, {wp_name}, {c_lp}, {lp_name});"
+
+    return f"// TODO: {name}"
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Diff Scintilla.iface against SciCall.h to find unwrapped messages"
+    )
+    parser.add_argument(
+        "--verbose", "-v", action="store_true",
+        help="Show detailed info for each unwrapped message"
+    )
+    parser.add_argument(
+        "--category", "-c", type=str, default=None,
+        help="Filter to a specific iface category (e.g. Basics, Provisional, Deprecated)"
+    )
+    parser.add_argument(
+        "--show-wrapped", "-w", action="store_true",
+        help="Also list messages that ARE wrapped (for completeness check)"
+    )
+    parser.add_argument(
+        "--generate", "-g", action="store_true",
+        help="Generate DeclareSciCall* lines for all unwrapped non-deprecated messages"
+    )
+    parser.add_argument(
+        "--iface", type=str, default=IFACE_PATH,
+        help=f"Path to Scintilla.iface (default: {IFACE_PATH})"
+    )
+    parser.add_argument(
+        "--scicall", type=str, default=SCICALL_PATH,
+        help=f"Path to SciCall.h (default: {SCICALL_PATH})"
+    )
+    args = parser.parse_args()
+
+    if not os.path.isfile(args.iface):
+        print(f"Error: {args.iface} not found", file=sys.stderr)
+        sys.exit(1)
+    if not os.path.isfile(args.scicall):
+        print(f"Error: {args.scicall} not found", file=sys.stderr)
+        sys.exit(1)
+
+    all_iface_msgs = parse_iface(args.iface)
+    scicall_wrappers = parse_scicall(args.scicall)
+
+    # Apply category filter for unwrapped/wrapped analysis
+    if args.category:
+        iface_msgs = {
+            k: v for k, v in all_iface_msgs.items()
+            if v["category"].lower() == args.category.lower()
+        }
+    else:
+        iface_msgs = all_iface_msgs
+
+    iface_keys = set(iface_msgs.keys())
+    all_iface_keys = set(all_iface_msgs.keys())
+    scicall_keys = set(scicall_wrappers.keys())
+
+    unwrapped = sorted(iface_keys - scicall_keys, key=lambda k: iface_msgs[k]["num"])
+    # Stale check always uses the full iface (not filtered)
+    stale = sorted(scicall_keys - all_iface_keys)
+    wrapped = sorted(iface_keys & scicall_keys, key=lambda k: iface_msgs[k]["num"])
+
+    # Generate mode: output DeclareSciCall* lines grouped by category
+    if args.generate:
+        non_deprecated = [
+            k for k in unwrapped if iface_msgs[k]["category"] != "Deprecated"
+        ]
+        by_cat = {}
+        for key in non_deprecated:
+            cat = iface_msgs[key]["category"]
+            by_cat.setdefault(cat, []).append(key)
+
+        for cat in sorted(by_cat.keys()):
+            keys = by_cat[cat]
+            print(f"// --- [{cat}] ({len(keys)} wrappers) ---")
+            for key in keys:
+                msg = iface_msgs[key]
+                line = generate_wrapper(msg)
+                print(line)
+            print()
+        print(f"// Total: {len(non_deprecated)} generated wrappers")
+        return 0
+
+    # Group unwrapped by category
+    unwrapped_by_cat = {}
+    for key in unwrapped:
+        cat = iface_msgs[key]["category"]
+        unwrapped_by_cat.setdefault(cat, []).append(key)
+
+    # Summary
+    cat_label = f" (category: {args.category})" if args.category else ""
+    print(f"=== SciCall.h Coverage Report{cat_label} ===")
+    print(f"  iface messages (fun/get/set): {len(iface_msgs)}")
+    print(f"  SciCall.h wrappers:           {len(scicall_wrappers)}")
+    print(f"  Wrapped (matched):            {len(wrapped)}")
+    print(f"  Unwrapped (missing):          {len(unwrapped)}")
+    print(f"  Stale/custom (no iface):      {len(stale)}")
+    print()
+
+    # Unwrapped messages
+    if unwrapped:
+        print(f"--- Unwrapped iface messages ({len(unwrapped)}) ---")
+        for cat in sorted(unwrapped_by_cat.keys()):
+            keys = unwrapped_by_cat[cat]
+            print(f"\n  [{cat}] ({len(keys)} messages)")
+            for key in keys:
+                msg = iface_msgs[key]
+                if args.verbose:
+                    print(f"    SCI_{key} = {msg['num']}")
+                    print(f"      {msg['type']} {msg['ret']} {msg['name']}({msg['params']})")
+                    print(f"      iface line {msg['line']}")
+                else:
+                    print(f"    SCI_{key:<45s} {msg['type']:<4s} {msg['ret']:<16s} {msg['name']}({msg['params']})")
+        print()
+
+    # Stale wrappers (in SciCall.h but not in iface)
+    if stale:
+        print(f"--- Stale/custom wrappers ({len(stale)}) ---")
+        print("  (In SciCall.h but no matching iface fun/get/set)")
+        for key in stale:
+            w = scicall_wrappers[key]
+            status = " [commented]" if w["commented"] else ""
+            print(f"    SCI_{key:<45s} SciCall_{w['fn']:<30s} line {w['line']}{status}")
+        print()
+
+    # Wrapped messages (optional)
+    if args.show_wrapped and wrapped:
+        print(f"--- Wrapped messages ({len(wrapped)}) ---")
+        for key in wrapped:
+            msg = iface_msgs[key]
+            w = scicall_wrappers[key]
+            status = " [commented]" if w["commented"] else ""
+            print(f"    SCI_{key:<45s} -> SciCall_{w['fn']}{status}")
+        print()
+
+    # Exit code: 0 if no unwrapped non-deprecated messages, 1 otherwise
+    non_deprecated_unwrapped = [
+        k for k in unwrapped if iface_msgs[k]["category"] != "Deprecated"
+    ]
+    if non_deprecated_unwrapped:
+        print(f"({len(non_deprecated_unwrapped)} unwrapped non-deprecated messages)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())