dotless 1.0.0__py3-none-any.whl

dotless/formats.py

@@ -0,0 +1,148 @@
+"""Output formats: text, JSON, SARIF 2.1.0 and GitLab Code Quality."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from collections import Counter
+
+from . import __version__
+from .rules import RULES
+from .scanner import Finding
+
+INFO_URI = "https://gitlab.com/rehimovv/dotless"
+
+
+def _rel(path: str) -> str:
+    try:
+        rel = os.path.relpath(path)
+    except ValueError:  # different drive on Windows
+        return path.replace(os.sep, "/")
+    return path.replace(os.sep, "/") if rel.startswith("..") else rel.replace(os.sep, "/")
+
+
+def _fingerprints(findings: list[Finding]) -> list[str]:
+    """Stable per-finding ids that survive unrelated line shifts."""
+    seen: Counter = Counter()
+    out = []
+    for f in findings:
+        base = f"{f.rule}\0{_rel(f.path)}\0{f.snippet}"
+        seen[base] += 1
+        out.append(hashlib.sha256(f"{base}\0{seen[base]}".encode()).hexdigest()[:32])
+    return out
+
+
+def summary(findings: list[Finding], files: int) -> str:
+    sev = Counter(f.severity for f in findings)
+    return (
+        f"{len(findings)} finding{'s' if len(findings) != 1 else ''} "
+        f"({sev['high']} high, {sev['low']} low) in {files} file{'s' if files != 1 else ''} scanned"
+    )
+
+
+def text(findings: list[Finding], files: int, color: bool = False) -> str:
+    def c(code: str, s: str) -> str:
+        return f"\033[{code}m{s}\033[0m" if color else s
+
+    lines = []
+    for f in findings:
+        sev = c("1;31", "high") if f.severity == "high" else c("33", "low")
+        title = RULES[f.rule].title or f.message
+        lines.append(f"{c('1', f'{_rel(f.path)}:{f.line}:{f.column}')}: [{sev}] {f.rule} {title}")
+        lines.append(f"    {f.snippet}")
+        lines.append(f"    {c('36', 'why:')} {f.reason}")
+        lines.append(f"    {c('36', 'fix:')} {f.fix}")
+    lines.append(summary(findings, files))
+    return "\n".join(lines) + "\n"
+
+
+def as_json(findings: list[Finding], files: int) -> str:
+    items = []
+    for f, fp in zip(findings, _fingerprints(findings)):
+        d = f.to_dict()
+        d["path"] = _rel(f.path)
+        d["fingerprint"] = fp
+        items.append(d)
+    return json.dumps({"tool": "dotless", "version": __version__, "files_scanned": files, "findings": items}, indent=2) + "\n"
+
+
+def sarif(findings: list[Finding], files: int) -> str:
+    rule_ids = sorted(RULES)
+    rules = [
+        {
+            "id": r.id,
+            "name": r.name,
+            "shortDescription": {"text": r.summary.split(":")[0]},
+            "fullDescription": {"text": r.summary},
+            "help": {"text": f"{r.summary}\n\nFix: {r.fix}", "markdown": f"{r.summary}\n\n**Fix:** {r.fix}"},
+            "helpUri": r.help_uri,
+            "defaultConfiguration": {"level": "warning"},
+            "properties": {"tags": ["i18n", "locale", "turkish", "azerbaijani"]},
+        }
+        for r in (RULES[i] for i in rule_ids)
+    ]
+    results = []
+    for f, fp in zip(findings, _fingerprints(findings)):
+        results.append(
+            {
+                "ruleId": f.rule,
+                "ruleIndex": rule_ids.index(f.rule),
+                "level": "error" if f.severity == "high" else "warning",
+                "message": {"text": f"{f.message} ({f.reason}). Fix: {f.fix}"},
+                "locations": [
+                    {
+                        "physicalLocation": {
+                            "artifactLocation": {"uri": _rel(f.path), "uriBaseId": "%SRCROOT%"},
+                            "region": {
+                                "startLine": f.line,
+                                "startColumn": f.column,
+                                "endColumn": max(f.end_column, f.column + 1),
+                            },
+                        }
+                    }
+                ],
+                "partialFingerprints": {"dotless/v1": fp},
+                "properties": {"severity": f.severity, "reason": f.reason},
+            }
+        )
+    doc = {
+        "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
+        "version": "2.1.0",
+        "runs": [
+            {
+                "tool": {
+                    "driver": {
+                        "name": "dotless",
+                        "version": __version__,
+                        "semanticVersion": __version__,
+                        "informationUri": INFO_URI,
+                        "rules": rules,
+                    }
+                },
+                "results": results,
+                "properties": {"filesScanned": files},
+            }
+        ],
+    }
+    return json.dumps(doc, indent=2) + "\n"
+
+
+def gitlab(findings: list[Finding], files: int) -> str:
+    """GitLab Code Quality report (CodeClimate subset)."""
+    items = [
+        {
+            "type": "issue",
+            "check_name": f"{f.rule} {RULES[f.rule].name}",
+            "description": f"{f.message} ({f.reason})",
+            "categories": ["Bug Risk"],
+            "severity": "major" if f.severity == "high" else "minor",
+            "fingerprint": fp,
+            "location": {"path": _rel(f.path), "lines": {"begin": f.line}},
+        }
+        for f, fp in zip(findings, _fingerprints(findings))
+    ]
+    return json.dumps(items, indent=2) + "\n"
+
+
+FORMATS = {"text": text, "json": as_json, "sarif": sarif, "gitlab": gitlab}

dotless/lexer.py

@@ -0,0 +1,286 @@
+"""A small lexer that separates code from comments and string literals.
+
+It is not a parser. It only needs to answer three questions reliably:
+is an offset inside a comment, inside a string literal, or in code; and
+what literal text sits at a given offset. To keep offsets stable, every
+view has exactly the same length as the source.
+
+``Source.code``  comments blanked, string literals kept
+``Source.bare``  comments and literal contents blanked, quote chars kept
+``Source.comments``  list of (line, text) for every comment
+"""
+
+from __future__ import annotations
+
+import bisect
+import re
+from dataclasses import dataclass, field
+
+
+_PY_PREFIX = re.compile(r"(?:[rR][bBfF]?|[bBfF][rR]?|[uU])(?=['\"])")
+_C_PREFIX = re.compile(r"(?:u8|[LuU])(?=['\"])")
+
+
+@dataclass(frozen=True)
+class Syntax:
+    line_comments: tuple[str, ...] = ("//",)
+    block_comment: tuple[str, str] | None = ("/*", "*/")
+    nested_blocks: bool = False
+    quotes: tuple[str, ...] = ('"', "'")
+    triple_quotes: tuple[str, ...] = ()  # Python ''' and """, Vala """
+    string_prefix: re.Pattern | None = None  # b"", L"", u8"" ...
+    template_quote: bool = False  # JavaScript `...`
+    regex_literals: bool = False  # JavaScript /.../
+    rust_chars: bool = False  # 'a' vs lifetime 'a
+    rust_raw: bool = False  # r"..." and r#"..."#
+
+
+C = Syntax(string_prefix=_C_PREFIX)
+VALA = Syntax(triple_quotes=('"""',), string_prefix=_C_PREFIX)
+PYTHON = Syntax(
+    line_comments=("#",),
+    block_comment=None,
+    triple_quotes=('"""', "'''"),
+    string_prefix=_PY_PREFIX,
+)
+JS = Syntax(template_quote=True, regex_literals=True)
+RUST = Syntax(
+    quotes=('"',), nested_blocks=True, rust_chars=True, rust_raw=True, string_prefix=re.compile(r'[bc](?=")')
+)
+
+# Characters after which a "/" in JavaScript starts a regex, not a division.
+_JS_REGEX_PREV = set("(,=:[!&|?{};+-*%<>~^")
+_JS_REGEX_KEYWORDS = ("return", "typeof", "case", "do", "else", "in", "of", "void", "yield")
+_RUST_CHAR = re.compile(r"'(?:\\u\{[0-9a-fA-F]{1,6}\}|\\x[0-9a-fA-F]{2}|\\.|[^\\'\n])'")
+_RUST_RAW = re.compile(r'b?r(#*)"')
+
+
+@dataclass
+class Source:
+    text: str
+    code: str
+    bare: str
+    comments: list[tuple[int, str]]
+    strings: list[tuple[int, int]]  # [start, end) of each literal incl. quotes
+    _line_starts: list[int] = field(default_factory=list, repr=False)
+
+    def __post_init__(self) -> None:
+        self._line_starts = [0] + [m.end() for m in re.finditer("\n", self.text)]
+        self._string_starts = [s for s, _ in self.strings]
+
+    def line_of(self, offset: int) -> int:
+        """1-based line number of an offset."""
+        return bisect.bisect_right(self._line_starts, offset)
+
+    def col_of(self, offset: int) -> int:
+        """1-based column of an offset."""
+        return offset - self._line_starts[self.line_of(offset) - 1] + 1
+
+    def line_offset(self, line: int) -> int:
+        if line - 1 >= len(self._line_starts):
+            return len(self.text)
+        return self._line_starts[line - 1]
+
+    def line_text(self, line: int) -> str:
+        start = self.line_offset(line)
+        end = self.text.find("\n", start)
+        return self.text[start : end if end >= 0 else len(self.text)]
+
+    def string_at(self, offset: int) -> tuple[int, int] | None:
+        """The literal span that starts exactly at ``offset``, if any."""
+        i = bisect.bisect_left(self._string_starts, offset)
+        if i < len(self.strings) and self.strings[i][0] == offset:
+            return self.strings[i]
+        return None
+
+    def in_string(self, offset: int) -> bool:
+        i = bisect.bisect_right(self._string_starts, offset) - 1
+        return i >= 0 and self.strings[i][0] <= offset < self.strings[i][1]
+
+
+def _blank(s: str) -> str:
+    return "".join("\n" if c == "\n" else " " for c in s)
+
+
+def lex(text: str, syntax: Syntax) -> Source:
+    n = len(text)
+    code: list[str] = []
+    bare: list[str] = []
+    comments: list[tuple[int, str]] = []
+    strings: list[tuple[int, int]] = []
+    line = 1
+    i = 0
+    last_sig = ""  # last significant code character, for JS regex detection
+    last_word = ""
+
+    def emit_comment(start: int, end: int) -> None:
+        nonlocal line
+        seg = text[start:end]
+        comments.append((line, seg))
+        blank = _blank(seg)
+        code.append(blank)
+        bare.append(blank)
+        line += seg.count("\n")
+
+    def emit_string(start: int, end: int, open_len: int, close_len: int) -> None:
+        nonlocal line
+        seg = text[start:end]
+        strings.append((start, end))
+        code.append(seg)
+        close = len(seg) - close_len
+        bare.append(seg[:open_len] + _blank(seg[open_len:close]) + seg[close:])
+        line += seg.count("\n")
+
+    def scan_quoted(start: int, quote: str, multiline: bool) -> int:
+        j = start + len(quote)
+        while j < n:
+            c = text[j]
+            if c == "\\":
+                j += 2
+                continue
+            if text.startswith(quote, j):
+                return j + len(quote)
+            if c == "\n" and not multiline:
+                return j
+            j += 1
+        return n
+
+    while i < n:
+        c = text[i]
+
+        # Comments.
+        lc = next((t for t in syntax.line_comments if text.startswith(t, i)), None)
+        if lc is not None:
+            end = text.find("\n", i)
+            end = n if end < 0 else end
+            emit_comment(i, end)
+            i = end
+            continue
+        if syntax.block_comment and text.startswith(syntax.block_comment[0], i):
+            op, cl = syntax.block_comment
+            depth, j = 1, i + len(op)
+            while j < n and depth:
+                if syntax.nested_blocks and text.startswith(op, j):
+                    depth += 1
+                    j += len(op)
+                elif text.startswith(cl, j):
+                    depth -= 1
+                    j += len(cl)
+                else:
+                    j += 1
+            emit_comment(i, j)
+            i = j
+            continue
+
+        # Rust raw strings and char literals / lifetimes.
+        if syntax.rust_raw and c in "rb" and (i == 0 or not (text[i - 1].isalnum() or text[i - 1] == "_")):
+            m = _RUST_RAW.match(text, i)
+            if m:
+                close = '"' + m.group(1)
+                end = text.find(close, m.end())
+                end = n if end < 0 else end + len(close)
+                emit_string(i, end, m.end() - i, len(close))
+                i = end
+                last_sig = '"'
+                continue
+        if syntax.rust_chars and c == "'":
+            m = _RUST_CHAR.match(text, i)
+            if m:
+                emit_string(i, m.end(), 1, 1)
+                i = m.end()
+                last_sig = "'"
+                continue
+            code.append(c)
+            bare.append(c)
+            i += 1
+            continue
+
+        # Strings.
+        start = i
+        if syntax.string_prefix and c.isalnum() and (i == 0 or not (text[i - 1].isalnum() or text[i - 1] == "_")):
+            m = syntax.string_prefix.match(text, i)
+            if m:
+                i = m.end()
+                c = text[i]
+        q = next((t for t in syntax.triple_quotes if text.startswith(t, i)), None)
+        if q is not None:
+            end = scan_quoted(i, q, True)
+            emit_string(start, end, i - start + 3, 3 if text.endswith(q, 0, end) else 0)
+            i = end
+            last_sig = '"'
+            continue
+        if c in syntax.quotes or (syntax.template_quote and c == "`"):
+            end = scan_quoted(i, c, c == "`")
+            emit_string(start, end, i - start + 1, 1 if end > i + 1 and text[end - 1] == c else 0)
+            i = end
+            last_sig = '"'
+            continue
+        i = start
+        c = text[i]
+
+        # JavaScript regex literals.
+        if syntax.regex_literals and c == "/" and (last_sig in _JS_REGEX_PREV or last_sig == "" or last_word in _JS_REGEX_KEYWORDS):
+            j, in_class = i + 1, False
+            while j < n and text[j] != "\n":
+                d = text[j]
+                if d == "\\":
+                    j += 2
+                    continue
+                if d == "[":
+                    in_class = True
+                elif d == "]":
+                    in_class = False
+                elif d == "/" and not in_class:
+                    break
+                j += 1
+            if j < n and text[j] == "/":
+                j += 1
+                while j < n and text[j].isalpha():
+                    j += 1
+                emit_string(i, j, 1, 0)
+                i = j
+                last_sig = '"'
+                continue
+
+        code.append(c)
+        bare.append(c)
+        if c == "\n":
+            line += 1
+        elif not c.isspace():
+            if c.isalnum() or c == "_" or c == "$":
+                j = i
+                while j < n and (text[j].isalnum() or text[j] in "_$"):
+                    j += 1
+                word = text[i:j]
+                code.append(word[1:])
+                bare.append(word[1:])
+                last_word = word
+                last_sig = "a"
+                i = j
+                continue
+            last_sig = c
+            last_word = ""
+        i += 1
+
+    return Source(text, "".join(code), "".join(bare), comments, strings)
+
+
+def literal_value(raw: str) -> str | None:
+    """Best-effort value of a string or char literal (quotes stripped).
+
+    Returns None for literals whose value cannot be known statically
+    (template literals with substitutions, Python f-strings, regexes).
+    """
+    m = re.match(r'^(?:[A-Za-z0-9]{0,2})("""|\'\'\'|"|\'|`)', raw)
+    if not m:
+        return None
+    prefix = raw[: m.start(1)].lower()
+    if "f" in prefix:
+        return None
+    q = m.group(1)
+    body = raw[m.end(1) :]
+    if body.endswith(q):
+        body = body[: -len(q)]
+    if q == "`" and "${" in body:
+        return None
+    return body

dotless/rules.py

@@ -0,0 +1,127 @@
+"""Rule catalogue.
+
+Every rule here corresponds to a row marked locale-dependent in
+docs/research.md. Functions that were measured to be locale independent
+(Python str.lower(), JavaScript toLowerCase(), Rust to_lowercase(),
+g_ascii_*, g_utf8_casefold(), g_unichar_tolower(), Vala ascii_down() ...)
+deliberately have no rule.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+C_LIKE = ("c",)
+
+
+@dataclass(frozen=True)
+class Rule:
+    id: str
+    name: str
+    languages: tuple[str, ...]
+    summary: str
+    fix: str
+    help_uri: str = "https://gitlab.com/rehimovv/dotless/-/blob/main/docs/rules.md"
+    title: str = ""  # one-line headline for text output
+
+
+RULES: dict[str, Rule] = {
+    r.id: r
+    for r in (
+        Rule(
+            "DL001",
+            "c-ctype-case",
+            ("c", "rust"),
+            "tolower()/toupper() follow LC_CTYPE: in tr_TR.UTF-8 and az_AZ.UTF-8 "
+            "glibc leaves 'I' and 'i' unchanged, in tr_TR.ISO-8859-9 it returns "
+            "the dotless/dotted variants.",
+            "Use g_ascii_tolower()/g_ascii_toupper() for ASCII data; in Rust, "
+            "u8::to_ascii_lowercase()/to_ascii_uppercase().",
+            title="tolower()/toupper() depend on the locale",
+        ),
+        Rule(
+            "DL002",
+            "c-strcasecmp",
+            ("c", "rust"),
+            "strcasecmp()-family comparisons follow LC_CTYPE: "
+            "strcasecmp(\"INTEGER\", \"integer\") != 0 in tr_TR and az_AZ.",
+            "Use g_ascii_strcasecmp()/g_ascii_strncasecmp() for ASCII keywords.",
+            title="strcasecmp()-style comparison depends on the locale",
+        ),
+        Rule(
+            "DL003",
+            "c-wide-case",
+            C_LIKE,
+            "towlower()/towupper() map 'I' to U+0131 and 'i' to U+0130 in Turkic locales.",
+            "Use g_unichar_tolower()/g_unichar_toupper() (locale independent), "
+            "or g_ascii_tolower() for ASCII data.",
+            title="towlower()/towupper() depend on the locale",
+        ),
+        Rule(
+            "DL004",
+            "glib-utf8-case",
+            ("c", "python", "js", "rust"),
+            "g_utf8_strdown()/g_utf8_strup() use Turkic rules when LC_CTYPE is "
+            "tr_* or az_*: \"INTEGER\" becomes \"ınteger\".",
+            "Use g_ascii_strdown()/g_ascii_strup() for identifiers, or "
+            "g_utf8_casefold() to compare human-readable text.",
+            title="g_utf8_strdown()/g_utf8_strup() follow Turkic rules in tr/az locales",
+        ),
+        Rule(
+            "DL005",
+            "glib-deprecated-case",
+            C_LIKE,
+            "Deprecated g_strdown()/g_strup()/g_strcasecmp()/g_strncasecmp() "
+            "use the C library's locale-dependent tolower()/toupper().",
+            "Use g_ascii_strdown()/g_ascii_strup()/g_ascii_strcasecmp().",
+            title="deprecated GLib case function depends on the locale",
+        ),
+        Rule(
+            "DL006",
+            "vala-string-case",
+            ("vala",),
+            "Vala string.down()/string.up() call g_utf8_strdown()/g_utf8_strup() "
+            "and follow the Turkic rules.",
+            "Use string.ascii_down()/string.ascii_up() for identifiers, or "
+            "string.casefold() to compare human-readable text.",
+            title="string.down()/string.up() follow Turkic rules in tr/az locales",
+        ),
+        Rule(
+            "DL007",
+            "gjs-locale-case",
+            ("js",),
+            "Under gjs, toLocaleLowerCase()/toLocaleUpperCase() without an explicit "
+            "locale use the process locale: 'INTEGER' becomes 'ınteger' in "
+            "tr_TR/az_AZ.",
+            "Use toLowerCase()/toUpperCase() (locale independent), or pass an "
+            "explicit locale.",
+            title="toLocaleLowerCase()/toLocaleUpperCase() without an explicit locale",
+        ),
+        Rule(
+            "DL008",
+            "js-localecompare-base",
+            ("js",),
+            "localeCompare() with sensitivity 'base' or 'accent' treats 'I' and 'i' "
+            "as different letters in Turkic locales.",
+            "Compare a.toLowerCase() === b.toLowerCase(), or pass an explicit "
+            "locale to localeCompare().",
+            title="localeCompare() equality with sensitivity 'base' or 'accent'",
+        ),
+        Rule(
+            "DL009",
+            "python-re-locale",
+            ("python",),
+            "re.LOCALE together with re.IGNORECASE uses the C library's tolower(): "
+            "b'INTEGER' does not match b'integer' in tr_TR/az_AZ.",
+            "Drop re.LOCALE (decode to str and use re.IGNORECASE), or use "
+            "explicit character classes.",
+            title="re.LOCALE with re.IGNORECASE depends on the locale",
+        ),
+    )
+}
+
+SEVERITIES = ("low", "high")
+
+
+def severity_rank(severity: str) -> int:
+    return SEVERITIES.index(severity)

dotless/runtime.py

@@ -0,0 +1,132 @@
+"""``dotless run``: run a command under Turkic locales and diff its output.
+
+The command runs once under a baseline locale (C.UTF-8) and once per test
+locale. Messages are kept untranslated (LANGUAGE=en) so that translation
+catalogues do not show up as differences; everything else follows the
+test locale, which is what a Turkish or Azerbaijani user gets.
+"""
+
+from __future__ import annotations
+
+import difflib
+import os
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+
+TURKIC_LETTERS = set("ıİ")
+
+
+@dataclass
+class Result:
+    locale: str
+    returncode: int | None
+    stdout: str
+    stderr: str
+    error: str | None = None
+
+
+def _norm(name: str) -> str:
+    return name.lower().replace("utf-8", "utf8").replace("-", "")
+
+
+def available_locales() -> set[str] | None:
+    """Normalised names from ``locale -a``, or None if unknown."""
+    if not shutil.which("locale"):
+        return None
+    try:
+        out = subprocess.run(["locale", "-a"], capture_output=True, text=True, timeout=10).stdout
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return {_norm(line.strip()) for line in out.splitlines() if line.strip()}
+
+
+def env_for(locale: str) -> dict[str, str]:
+    env = dict(os.environ)
+    for k in list(env):
+        if k.startswith("LC_"):
+            del env[k]
+    env["LC_ALL"] = locale
+    env["LANG"] = locale
+    env["LANGUAGE"] = "en"
+    return env
+
+
+def run_once(cmd: list[str], locale: str, timeout: float, stdin_data: bytes | None) -> Result:
+    try:
+        p = subprocess.run(cmd, env=env_for(locale), input=stdin_data, capture_output=True, timeout=timeout)
+    except FileNotFoundError:
+        return Result(locale, None, "", "", f"command not found: {cmd[0]}")
+    except subprocess.TimeoutExpired:
+        return Result(locale, None, "", "", f"timed out after {timeout:g}s")
+    dec = lambda b: b.decode("utf-8", errors="replace")  # noqa: E731
+    return Result(locale, p.returncode, dec(p.stdout), dec(p.stderr))
+
+
+def _diff(a: str, b: str, name_a: str, name_b: str, limit: int = 40) -> list[str]:
+    lines = list(difflib.unified_diff(a.splitlines(), b.splitlines(), name_a, name_b, lineterm="", n=1))
+    if len(lines) > limit:
+        lines = lines[:limit] + [f"... ({len(lines) - limit} more diff lines)"]
+    return lines
+
+
+def compare(base: Result, other: Result) -> list[str]:
+    """Human-readable differences between two runs (empty if identical)."""
+    report = []
+    if base.returncode != other.returncode:
+        report.append(f"exit status: {base.returncode} under {base.locale}, {other.returncode} under {other.locale}")
+    for stream in ("stdout", "stderr"):
+        a, b = getattr(base, stream), getattr(other, stream)
+        if a != b:
+            report.append(f"{stream} differs:")
+            report.extend("  " + line for line in _diff(a, b, f"{stream}@{base.locale}", f"{stream}@{other.locale}"))
+            new = (set(b) & TURKIC_LETTERS) - set(a)
+            if new:
+                report.append(f"  note: output under {other.locale} contains {', '.join(sorted(new))}, "
+                              f"which the {base.locale} output does not (Turkic case mapping)")
+    return report
+
+
+def run_compare(cmd: list[str], locales: list[str], baseline: str, timeout: float, stdin_path: str | None) -> int:
+    stdin_data = None
+    if stdin_path:
+        with open(stdin_path, "rb") as fh:
+            stdin_data = fh.read()
+
+    known = available_locales()
+    if known is None:
+        print("dotless run: cannot list locales (no `locale` command); results may be meaningless "
+              "on systems without glibc locales", file=sys.stderr)
+    else:
+        missing = [loc for loc in [baseline, *locales] if _norm(loc) not in known]
+        for loc in missing:
+            lang, _, enc = loc.partition(".")
+            print(f"dotless run: locale {loc} is not installed; generate it with: "
+                  f"localedef -i {lang} -f {enc or 'UTF-8'} {loc}", file=sys.stderr)
+        if baseline in missing:
+            return 2
+        locales = [loc for loc in locales if loc not in missing]
+        if not locales:
+            return 2
+
+    base = run_once(cmd, baseline, timeout, stdin_data)
+    if base.error:
+        print(f"dotless run: {base.error}", file=sys.stderr)
+        return 2
+
+    differs = False
+    for loc in locales:
+        res = run_once(cmd, loc, timeout, stdin_data)
+        if res.error:
+            print(f"[{loc}] {res.error}")
+            differs = True
+            continue
+        report = compare(base, res)
+        if report:
+            differs = True
+            print(f"[{loc}] output differs from {baseline}:")
+            print("\n".join(report))
+        else:
+            print(f"[{loc}] same output as {baseline}")
+    return 1 if differs else 0