nativegate 0.1.8__tar.gz → 0.1.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nativegate
-Version: 0.1.8
+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.8 → 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.8 → 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.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.8 → nativegate-0.1.9}/nativegate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nativegate
-Version: 0.1.8
+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.8 → 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
@@ -78,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.8 → nativegate-0.1.9}/pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nativegate"
-version = "0.1.8"
+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_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)