nativegate 0.1.7__tar.gz → 0.1.9__tar.gz

{nativegate-0.1.7 → nativegate-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nativegate
-Version: 0.1.7
+Version: 0.1.9
 Summary: Make legacy C++/C/Fortran AI-ready and microservice-ready: expose native code as an MCP server, REST API and container
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -552,3 +552,10 @@ mapping. Each refusal is printed at `generate` time with its reason, and the
 generated service publishes them at `GET /_unexposed` so they stay visible to
 whoever is calling the API. An empty mapping there means this build refused
 nothing; a 404 means the service predates the route and cannot tell you.
+
+## Community
+
+Contributing: see the repository's [CONTRIBUTING.md](../../CONTRIBUTING.md).
+Participation in this project's spaces is covered by the
+[Code of Conduct](../../CODE_OF_CONDUCT.md); reports go to
+sr.rabiu@gmail.com.

{nativegate-0.1.7 → nativegate-0.1.9}/README.md

@@ -519,3 +519,10 @@ mapping. Each refusal is printed at `generate` time with its reason, and the
 generated service publishes them at `GET /_unexposed` so they stay visible to
 whoever is calling the API. An empty mapping there means this build refused
 nothing; a 404 means the service predates the route and cannot tell you.
+
+## Community
+
+Contributing: see the repository's [CONTRIBUTING.md](../../CONTRIBUTING.md).
+Participation in this project's spaces is covered by the
+[Code of Conduct](../../CODE_OF_CONDUCT.md); reports go to
+sr.rabiu@gmail.com.

{nativegate-0.1.7 → nativegate-0.1.9}/nativegate/parsers/fortran.py

@@ -65,10 +65,12 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
+import tempfile
 
 from ..config import ExposeConfig
 from ..ir import ModuleIR
 from . import fortran_fparser, fortran_regex
+from . import hollerith
 
 # Re-exported so callers that reach for the free-form continuation joiner (the
 # CLI's source-rewriting paths, and a good number of tests) keep working after
@@ -137,6 +139,31 @@ def backend_description(backend: str | None = None) -> str:
     )
 
 
+def _hollerith_resolved(path: Path) -> Path | None:
+    """A temp copy of `path` with Hollerith constants resolved, or None.
+
+    fparser2 refuses Hollerith constants gfortran compiles with a warning —
+    the one measured counterexample to the parity rule that made fparser2
+    the default (DEFECTS D15, netlib quadpack). The file gfortran accepts
+    is the file that should parse, so the front door resolves the constants
+    into their standard quoted spelling and reads that copy instead. The
+    copy is attributed back to the original path, so source-file references
+    and doc-comment line spans keep pointing at the real file.
+    """
+    raw = path.read_text()
+    if not hollerith.is_hollerith(raw):
+        return None
+    resolved, _ = hollerith.resolve_hollerith(raw)
+    handle, name = tempfile.mkstemp(suffix=path.suffix)
+    Path(name).write_text(resolved)
+    # mkstemp exposes an int fd; close it — Path.write_text already used
+    # a second open, and the raw descriptor must not leak.
+    import os
+
+    os.close(handle)
+    return Path(name)
+
+
 def parse_source(
     path: Path,
     expose: ExposeConfig,
@@ -146,6 +173,15 @@ def parse_source(
 ) -> ModuleIR:
     """Parse one Fortran source into a ModuleIR using the selected backend."""
     if resolve_backend(backend) == "fparser2":
+        resolved = _hollerith_resolved(path)
+        if resolved is not None:
+            module = fortran_fparser.parse_source(resolved, expose, include_paths)
+            # The temp copy must not leak into user-visible IR: same name,
+            # same source file, only the text differs (D15).
+            module.name = path.stem
+            module.source_file = str(path)
+            resolved.unlink(missing_ok=True)
+            return module
         return fortran_fparser.parse_source(path, expose, include_paths)
     return fortran_regex.parse_source(path, expose, include_paths)
 
@@ -153,5 +189,11 @@ def parse_source(
 def list_routine_names(path: Path, *, backend: str | None = None) -> list[str]:
     """Every function/subroutine name in the file, in source order."""
     if resolve_backend(backend) == "fparser2":
+        resolved = _hollerith_resolved(path)
+        if resolved is not None:
+            try:
+                return fortran_fparser.list_routine_names(resolved)
+            finally:
+                resolved.unlink(missing_ok=True)
         return fortran_fparser.list_routine_names(path)
     return fortran_regex.list_routine_names(path)

{nativegate-0.1.7 → nativegate-0.1.9}/nativegate/parsers/fortran_fparser.py

@@ -454,6 +454,13 @@ class _Declarations:
     derived_intents: dict[str, str] = field(default_factory=dict)
     # Names given a shape by a standalone DIMENSION statement.
     dimensioned: set[str] = field(default_factory=set)
+    # Names declared EXTERNAL — Fortran procedure dummies (callbacks). f2py
+    # binds these only with per-argument callback directives, which nativegate
+    # does not generate; typing one by its IMPLICIT fallback (`real`, because
+    # 'f' is not in the I-N band) produced a binding that builds, imports,
+    # passes its smoke test and hands Fortran garbage at call time. Recorded
+    # first contact: netlib quadpack's QNG/QAGSE (DEFECTS D14).
+    external: set[str] = field(default_factory=set)
 
 
 def _parse_declarations(spec_part) -> _Declarations:
@@ -468,6 +475,17 @@ def _parse_declarations(spec_part) -> _Declarations:
         for item in stmt.items[0]:
             result.dimensioned.add(_name_of(item[0]).lower())
 
+    # EXTERNAL names are Fortran procedure dummies — callbacks. See the
+    # `external` field note above for why typing them is a silently wrong
+    # answer, and DEFECTS D14 for the netlib quadpack contact. External_Name
+    # nodes never appear as standalone tree entries, so read the names off
+    # External_Stmt.items: item 0 is the keyword, the last is the name list
+    # (the arity lines up across the fixed- and free-form grammars).
+    for stmt in _walk(spec_part, _F.External_Stmt):
+        name_list = stmt.items[-1]
+        for item in getattr(name_list, "items", ()):
+            result.external.add(_name_of(item).lower())
+
     for decl in _walk(spec_part, _F.Type_Declaration_Stmt):
         type_spec = decl.items[0]
         if _is_derived(type_spec):
@@ -698,17 +716,30 @@ def _resolve_parameters(
     declared: dict[str, Parameter],
     unbindable: dict[str, str],
     implicit_map: dict[str, str],
+    external_names: set[str] = frozenset(),
 ) -> list[Parameter]:
     """Type every dummy argument, or refuse the routine.
 
-    Three sources in decreasing authority: an explicit declaration, a
-    recognised-but-unbindable declaration (refuse), and IMPLICIT typing. There
-    is deliberately no fourth "assume float" step — the reason the reasons
-    below exist at all.
+    Four sources in decreasing authority: EXTERNAL declarations (refuse the
+    routine — callbacks have their own semantic and no generated binding),
+    an explicit declaration, a recognised-but-unbindable declaration
+    (refuse), and IMPLICIT typing. There is deliberately no fifth "assume
+    float" step — the reason the reasons below exist at all.
     """
     parameters: list[Parameter] = []
     for param_name in param_names:
         key = param_name.lower()
+        # EXTERNAL check ahead of every type lookup: a name in the external
+        # list is a procedure dummy, whatever it implicitly types as. 'f' is
+        # not in the I-N band, so the fallback it used to hit was real/float.
+        if key in external_names:
+            raise _RoutineSkipped(
+                f"argument '{param_name}' is declared EXTERNAL (a Fortran "
+                "procedure/callback). f2py binds callbacks only through per-"
+                "argument f2py directives, which the generator does not emit "
+                "yet — this routine is skipped as a whole rather than bound "
+                "with the callback mis-typed as a scalar."
+            )
         if key in declared:
             parameters.append(declared[key])
             continue
@@ -824,11 +855,11 @@ def _free_form_routine(
                 parameters.extend(flat_by_param[param])
             else:
                 parameters.extend(
-                    _resolve_parameters([param], declared, unbindable, implicit_map)
+                    _resolve_parameters([param], declared, unbindable, implicit_map, decls.external)
                 )
     else:
         parameters = _resolve_parameters(
-            param_names, declared, unbindable, implicit_map
+            param_names, declared, unbindable, implicit_map, decls.external
         )
 
     if is_subroutine:
@@ -987,8 +1018,26 @@ def _parse_fixed_form(path: Path, expose: ExposeConfig, include_paths: list[Path
         )
 
         parameters = []
+        external_refused = False
         for param_name in param_names:
             key = param_name.lower()
+            # Ahead of every type lookup: an EXTERNAL name is a procedure
+            # dummy whatever it implicitly types as (DEFECTS D14 — netlib
+            # quadpack QNG/QAGSE).
+            if key in decls.external:
+                module.skipped.append(
+                    SkippedSymbol(
+                        name,
+                        f"argument '{param_name}' is declared EXTERNAL (a "
+                        "Fortran procedure/callback). f2py binds callbacks "
+                        "only through per-argument f2py directives, which "
+                        "the generator does not emit yet — skipped as a "
+                        "whole rather than bound with the callback "
+                        "mis-typed as a scalar.",
+                    )
+                )
+                external_refused = True
+                break
             declaration = decls.declared.get(key)
             if declaration is not None:
                 py_type = declaration.type
@@ -1068,6 +1117,10 @@ def _parse_fixed_form(path: Path, expose: ExposeConfig, include_paths: list[Path
             )
             returns = map_fortran_type(base) if base else "float"
 
+        if external_refused:
+            # Recorded in module.skipped; nothing downstream may wrap it.
+            continue
+
         module.functions.append(
             FunctionDef(
                 name=name,

{nativegate-0.1.7 → nativegate-0.1.9}/nativegate/parsers/fortran_regex.py

@@ -299,6 +299,29 @@ def _parse_derived_declarations(body: str) -> dict[str, str]:
     return unbindable
 
 
+# EXTERNAL declarations name Fortran procedure dummies — callbacks. Stands
+# in the fixed-form `external f` shape AND the free-form `external :: f, g`
+# one. Collected so the routine that takes one is skipped with a reason
+# (both readers, identical text): typing it through the IMPLICIT fallback —
+# 'f' is real, since 'f' sits outside the I-N integer band — produced a
+# binding that builds, imports, smokes green and hands Fortran garbage at
+# call time. First contact: netlib quadpack QNG/QAGSE (DEFECTS D14).
+_EXTERNAL_RE = re.compile(
+    r"^[ \t]*external[ \t]*(?::[ \t]*)?([a-z][a-z0-9_, \t]*)$",
+    re.IGNORECASE | re.MULTILINE,
+)
+
+
+def _external_declared_names(body: str) -> set[str]:
+    out: set[str] = set()
+    for match in _EXTERNAL_RE.finditer(body):
+        for raw in match.group(1).split(","):
+            name = raw.strip().lower()
+            if name:
+                out.add(name)
+    return out
+
+
 def _parse_declarations(body: str) -> dict[str, Parameter]:
     """Map declared variable name -> Parameter, for every `type, attrs :: names` line in body."""
     declared: dict[str, Parameter] = {}
@@ -336,19 +359,34 @@ def _resolve_parameters(
     declared: dict[str, Parameter],
     unbindable: dict[str, str],
     implicit_map: dict[str, str],
+    external_names=None,
 ) -> list[Parameter]:
     """Type every dummy argument, or refuse the routine.
 
-    Three sources in decreasing authority: an explicit declaration, a
-    recognised-but-unbindable declaration (refuse), and IMPLICIT typing.
-    There is deliberately no fourth "assume float" step.
+    Four sources in decreasing authority: EXTERNAL declarations (refuse the
+    routine — a callback typed via the IMPLICIT fallback is a buildable,
+    importable, silently wrong binding; see DEFECTS D14 / netlib quadpack),
+    an explicit declaration, a recognised-but-unbindable declaration
+    (refuse), and IMPLICIT typing. There is deliberately no fifth "assume
+    float" step.
     """
+    external_names = external_names if external_names is not None else set()
     raw_params = match.group("params") or ""
     param_names = [p.strip() for p in raw_params.split(",") if p.strip()]
 
     parameters: list[Parameter] = []
     for param_name in param_names:
         key = param_name.lower()
+        # Ahead of every type lookup: an EXTERNAL name is a procedure dummy
+        # whatever it implicitly types as — see the note on _EXTERNAL_RE.
+        if key in (external_names or ()):
+            raise _RoutineSkipped(
+                f"argument '{param_name}' is declared EXTERNAL (a Fortran "
+                "procedure/callback). f2py binds callbacks only through per-"
+                "argument f2py directives, which the generator does not emit "
+                "yet — this routine is skipped as a whole rather than bound "
+                "with the callback mis-typed as a scalar."
+            )
         if key in declared:
             parameters.append(declared[key])
             continue
@@ -431,7 +469,9 @@ def _extract_function(
     declared = _parse_declarations(body)
     unbindable = _parse_derived_declarations(body)
 
-    parameters = _resolve_parameters(match, declared, unbindable, implicit_map)
+    parameters = _resolve_parameters(
+        match, declared, unbindable, implicit_map, _external_declared_names(body)
+    )
 
     result_name = (match.group("result") or name).lower()
     result_param = declared.get(result_name)
@@ -476,7 +516,9 @@ def _extract_subroutine(
     declared = _parse_declarations(body)
     unbindable = _parse_derived_declarations(body)
 
-    parameters = _resolve_parameters(match, declared, unbindable, implicit_map)
+    parameters = _resolve_parameters(
+        match, declared, unbindable, implicit_map, _external_declared_names(body)
+    )
 
     enclosing = _enclosing_fortran_module(source, match.start())
     fn = FunctionDef(
@@ -537,9 +579,32 @@ def _parse_fixed_form_source(
         # `STEP(DTIN, DTOUT, ICONV)` would return None.
         intents = fixed_form.infer_intents(routine, normalized)
 
+        # The fixed-form half has its own declaration scan (`find_routine` +
+        # `declared_types`), which never consulted the free-form extractors
+        # — so an `external f` (a Fortran procedure dummy) typed straight
+        # through the IMPLICIT fallback to `real`/float and produced a
+        # binding that builds, imports, passes its smoke test and hands
+        # Fortran garbage at call time. Found on netlib quadpack QNG/QAGSE
+        # (DEFECTS D14); refusal is the interpretation both backends share.
+        external_names = _external_declared_names(routine["body"])
         parameters = []
         for param_name in routine["params"]:
             key = param_name.lower()
+            # Ahead of every type lookup: an EXTERNAL name is a procedure
+            # dummy whatever it implicitly types as — see the note above.
+            if key in external_names:
+                module.skipped.append(
+                    SkippedSymbol(
+                        name,
+                        f"argument '{param_name}' is declared EXTERNAL (a "
+                        "Fortran procedure/callback). f2py binds callbacks "
+                        "only through per-argument f2py directives, which "
+                        "the generator does not emit yet — skipped as a "
+                        "whole rather than bound with the callback "
+                        "mis-typed as a scalar.",
+                    )
+                )
+                break
             base_type = routine["declared_types"].get(key) or fixed_form.implicit_type_of(
                 param_name, implicit_map
             )
@@ -602,6 +667,11 @@ def _parse_fixed_form_source(
             )
             returns = map_fortran_type(base) if base else "float"
 
+        # A routine whose whole binding was refused (external callback) has
+        # been recorded in module.skipped; nothing downstream may wrap it.
+        if any(s.name == name for s in module.skipped):
+            continue
+
         module.functions.append(
             FunctionDef(
                 name=name,

nativegate-0.1.9/nativegate/parsers/hollerith.py

@@ -0,0 +1,93 @@
+"""Hollerith constants in fixed-form Fortran — rewrite to CHARACTER literals.
+
+The netlib quadpack contact (DEFECTS D15) is the canonical case: 1970s-era
+sources pass error text as Hollerith constants,
+
+    call xerror(26habnormal return from  qng ,26,ier,0)
+
+gfortran compiles that (legacy extension, warning only), but fparser2
+refuses the whole file — the first measured counterexample to the
+"fparser2 is never stricter than gfortran" rule that justifies fparser2
+being the default front end. Since nativegate must compile with gfortran
+anyway, the file gfortran accepts is exactly the file that should reach
+the parser; the quoted CHARACTER constant is the standard F77 spelling of
+the same argument, which f2py's own reader accepts too.
+
+Deliberately conservative:
+
+* Fixed-form text only; F90+ sources do not carry Hollerith.
+* One constant per physical line: an `N*H` whose count runs past the line
+  end (it continues onto the next) is left untouched — rewriting it would
+  move every following line number and shift the doc-comment spans both
+  backends position by line.
+* The rewritten line must fit the punch-card margin (72 columns). One
+  that cannot is left alone. What survives un-resolved is the caller's
+  decision (see resolver_hollerith in parsers/fortran.py).
+"""
+
+from __future__ import annotations
+
+import re
+
+_HOLLERITH_START_RE = re.compile(r"(?<!\w)(\d+)\s*[hH]", re.ASCII)
+
+_FIXED_FORM_LINE_LIMIT = 72
+
+
+def is_hollerith(text: str) -> bool:
+    return bool(_HOLLERITH_START_RE.search(text))
+
+
+def resolve_hollerith(text: str) -> tuple[str, int]:
+    """Replace resolvable Hollerith constants with quoted literals, in line.
+
+    Returns (text, resolved). Line count is always preserved, so line-based
+    spans (doc comments, fparser2 item spans) stay put — the same invariant
+    the dialect pass keeps.
+    """
+    if not is_hollerith(text):
+        return text, 0
+
+    out_lines = []
+    resolved_total = 0
+    for line in text.splitlines(keepends=True):
+        resolved_line, n = _resolve_line(line)
+        out_lines.append(resolved_line)
+        resolved_total += n
+    return "".join(out_lines), resolved_total
+
+
+def _resolve_line(line: str) -> tuple[str, int]:
+    """Substitute every fitting Hollerith constant on one physical line."""
+    end_of_line = len(line.rstrip("\r\n"))
+    eol = line[end_of_line:]
+    body = line[:end_of_line]
+
+    resolved = 0
+    position = 0
+    while position <= len(body):
+        match = _HOLLERITH_START_RE.search(body, position)
+        if match is None:
+            break
+        count = int(match.group(1))
+        start = match.end()
+        if start + count > len(body):
+            # the constant counts past this physical line — it continues on
+            # the next; rewriting it would move following line numbers
+            break
+        literal = body[start : start + count]
+        quoted = _quote(literal)
+        new_line = f"{body[: match.start()]}{quoted}{body[start + count :]}"
+        if len(new_line) > _FIXED_FORM_LINE_LIMIT:
+            # never widen the punch-card margin; leave this one alone
+            break
+        body = new_line
+        resolved += 1
+        position = match.start() + len(quoted)
+    return body + eol, resolved
+
+
+def _quote(literal: str) -> str:
+    if "'" in literal:
+        return '"' + literal.replace('"', '""') + '"'
+    return "'" + literal + "'"

{nativegate-0.1.7 → nativegate-0.1.9}/nativegate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nativegate
-Version: 0.1.7
+Version: 0.1.9
 Summary: Make legacy C++/C/Fortran AI-ready and microservice-ready: expose native code as an MCP server, REST API and container
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -552,3 +552,10 @@ mapping. Each refusal is printed at `generate` time with its reason, and the
 generated service publishes them at `GET /_unexposed` so they stay visible to
 whoever is calling the API. An empty mapping there means this build refused
 nothing; a 404 means the service predates the route and cannot tell you.
+
+## Community
+
+Contributing: see the repository's [CONTRIBUTING.md](../../CONTRIBUTING.md).
+Participation in this project's spaces is covered by the
+[Code of Conduct](../../CODE_OF_CONDUCT.md); reports go to
+sr.rabiu@gmail.com.

{nativegate-0.1.7 → nativegate-0.1.9}/nativegate.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ nativegate/parsers/fixed_form.py
 nativegate/parsers/fortran.py
 nativegate/parsers/fortran_fparser.py
 nativegate/parsers/fortran_regex.py
+nativegate/parsers/hollerith.py
 nativegate/templates/__init__.py
 nativegate/templates/golden_test_template.py
 tests/test_buildinfo.py
@@ -68,6 +69,7 @@ tests/test_dialect.py
 tests/test_docker_gen.py
 tests/test_driverbuild.py
 tests/test_endpoint_docstrings.py
+tests/test_external_callbacks.py
 tests/test_fixed_form.py
 tests/test_fortran_doc_comments.py
 tests/test_fortran_driver.py
@@ -77,6 +79,7 @@ tests/test_fortran_pipeline.py
 tests/test_gateway_gen.py
 tests/test_generated_python_is_valid.py
 tests/test_golden.py
+tests/test_hollerith.py
 tests/test_inspect_dialect.py
 tests/test_invariants.py
 tests/test_ir_contract.py

{nativegate-0.1.7 → nativegate-0.1.9}/pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nativegate"
-version = "0.1.7"
+version = "0.1.9"
 description = "Make legacy C++/C/Fortran AI-ready and microservice-ready: expose native code as an MCP server, REST API and container"
 readme = "README.md"
 requires-python = ">=3.10"

nativegate-0.1.9/tests/test_external_callbacks.py

@@ -0,0 +1,79 @@
+"""D14: `external` dummies are callbacks — refusing to type them.
+
+First contact: netlib quadpack QAGSE (f2py itself refuses — 'external f
+is not in lcb_map[]'). The regex reader's IMPLICIT fallback typed 'f' as
+`real` -> float: a binding that builds, imports, passes its smoke test
+and hands the Fortran side garbage at call time. Both backends now
+refuse the routine as a whole with the reason; ModuleIR.skipped carries
+it. NOTE: the synthetic decks are written with hard six-space margins —
+textwrap.dedent strips the shared indent and the files stop being
+fixed-form.
+"""
+
+from pathlib import Path
+
+from nativegate.config import ExposeConfig
+from nativegate.parsers import fortran as fortran_parser
+
+HEADER_SUB = (
+    "      SUBROUTINE QNG(F, A, B)\n"
+    "      EXTERNAL F\n"
+    "      REAL A, B\n"
+    "      END\n"
+)
+
+HEADER_FREE = (
+    "subroutine qng(f, a, b)\n"
+    "  external f\n"
+    "  real a, b\n"
+    "end subroutine qng\n"
+)
+
+HEADER_PLAIN = (
+    "      SUBROUTINE ASSOC(A, B)\n"
+    "      REAL A, B\n"
+    "      A = B\n"
+    "      RETURN\n"
+    "      END\n"
+)
+
+
+def test_regex_backend_reports_external_dummy_as_skip(tmp_path):
+    src = tmp_path / "qng.f"
+    src.write_text(HEADER_SUB)
+    module = fortran_parser.parse_source(
+        src, ExposeConfig(functions=["QNG"]), backend="regex"
+    )
+    assert module.functions == []
+    assert len(module.skipped) == 1
+    assert module.skipped[0].name == "QNG"
+    assert "EXTERNAL" in module.skipped[0].reason
+
+
+def test_fparser_backend_reports_external_dummy_as_skip(tmp_path):
+    src = tmp_path / "qng.f"
+    src.write_text(HEADER_SUB)
+    module = fortran_parser.parse_source(
+        src, ExposeConfig(functions=["QNG"]), backend="fparser2"
+    )
+    assert module.functions == []
+    assert "EXTERNAL" in module.skipped[0].reason
+
+
+def test_free_form_backend_also_refuses_callbacks(tmp_path):
+    src = tmp_path / "qng.f90"
+    src.write_text(HEADER_FREE)
+    module = fortran_parser.parse_source(
+        src, ExposeConfig(functions=["qng"]), backend="regex"
+    )
+    assert module.functions == []
+    assert len(module.skipped) == 1
+
+
+def test_routines_without_callbacks_still_bind(tmp_path):
+    src = tmp_path / "g.f"
+    src.write_text(HEADER_PLAIN)
+    module = fortran_parser.parse_source(
+        src, ExposeConfig(functions=["ASSOC"]), backend="regex"
+    )
+    assert [p.name.lower() for p in module.functions[0].parameters] == ["a", "b"]

nativegate-0.1.9/tests/test_hollerith.py

@@ -0,0 +1,84 @@
+"""D15: Hollerith constants resolve so fparser2 reads gfortran-acceptable files.
+
+`call xerror(26habnormal return from  qng ,26,ier,0)` compiles under
+gfortran with a legacy-extension warning but made fparser2 refuse the
+whole file — QUADPACK's QNG, un-inspectable at the default backend. The
+front door now resolves these into the standard quoted spelling in a temp
+copy attributed back to the original path (same module name, same source
+file reference, same line count), so both `inspect` and `generate` see
+the file the compiler sees.
+"""
+
+import textwrap
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from nativegate import cli
+from nativegate.parsers import fortran as fortran_parser
+from nativegate.parsers import hollerith
+from nativegate.config import ExposeConfig
+
+QNG_WITH_HOLLERITH = (
+    "      SUBROUTINE QNG(F, A, B)\n"
+    "      EXTERNAL F\n"
+    "      REAL A, B\n"
+    "         IF (IER.NE.0) THEN\n"
+    "   80 CALL XERROR(26HABNORMAL RETURN FROM  QNG ,26,IER,0)\n"
+    "         END IF\n"
+    "      RETURN\n"
+    "      END\n"
+)
+
+
+def test_resolver_quotes_and_preserves_columns():
+    source = QNG_WITH_HOLLERITH
+    out, resolved = hollerith.resolve_hollerith(source)
+    assert resolved == 1
+    assert "26HABNORMAL" not in out
+    assert "'ABNORMAL RETURN FROM  QNG '" in out
+    # line count and margin are invariants: every physical line stays
+    assert out.count("\n") == source.count("\n")
+    for original, rewritten in zip(source.splitlines(), out.splitlines()):
+        assert len(rewritten) <= 72
+
+
+def test_resolver_leaves_continuation_spanning_constants():
+    # the constant counts past the physical line: untouched, so line
+    # numbers never shift
+    text = "      CALL XERROR(6HABCDE\n      -F,6,IER,0)\n"
+    out, resolved = hollerith.resolve_hollerith(text)
+    assert resolved == 0
+    assert out == text
+
+
+def test_resolver_is_a_noop_without_hollerith():
+    text = "      REAL A\n      A = 2.0\n"
+    out, resolved = hollerith.resolve_hollerith(text)
+    assert resolved == 0 and out == text
+
+
+def test_quote_escapes_are_balanced():
+    assert hollerith._quote("it's") == '"it\'s"'
+    assert hollerith._quote('say "hi"') == '\'say "hi"\''
+
+
+def test_inspect_parses_hollerith_deck_by_default(tmp_path):
+    src = tmp_path / "qng.f"
+    src.write_text(QNG_WITH_HOLLERITH)
+    # the ONE check that matters: no explicit backend flag, the default
+    # (fparser2 where importable) reads the file the compiler reads
+    result = CliRunner().invoke(
+        cli.main, ["inspect", str(src), "--function", "QNG"]
+    )
+    assert result.exit_code == 0, result.output
+    # the callback is refused with its reason, never mis-typed (D14)
+    assert "EXTERNAL" in result.output
+
+
+def test_module_name_attributed_to_real_file(tmp_path):
+    src = tmp_path / "qng.f"
+    src.write_text(QNG_WITH_HOLLERITH)
+    module = fortran_parser.parse_source(src, ExposeConfig(functions=["QNG"]))
+    assert module.name == "qng"
+    assert module.source_file == str(src)