nativegate 0.1.6__tar.gz → 0.1.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nativegate
-Version: 0.1.6
+Version: 0.1.8
 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

{nativegate-0.1.6 → nativegate-0.1.8}/nativegate/cli.py

@@ -10,6 +10,7 @@ import json
 import shutil
 import subprocess
 import sys
+import tempfile
 from pathlib import Path
 
 import click
@@ -513,12 +514,21 @@ def suggest(path: Path, parser: str, includes: tuple[str, ...], show_all: bool,
     show_default=True,
     help="C++ only: language standard for the AST parse.",
 )
+@click.option(
+    "--dialect",
+    default="",
+    help="Fortran only: resolve netlib CS/CD dual-dialect marking "
+    "('cs' or 'cd') in a temporary copy before parsing. Mirrors "
+    "nativegate.yaml's `dialect:` so `ngate inspect` answers the same "
+    "questions about a marked source that `generate` will.",
+)
 def inspect(
     path: Path,
     functions: tuple[str, ...],
     parser: str,
     includes: tuple[str, ...],
     std: str,
+    dialect: str,
 ) -> None:
     """Parse a native source file and print the resulting IR."""
     lang = detect_language(path)
@@ -539,7 +549,24 @@ def inspect(
                 "Fortran sources need at least one --function <name> to target "
                 "(large legacy files are parsed one routine at a time)."
             )
-        module = fortran_parser.parse_source(path, ExposeConfig(functions=list(functions)))
+        inspect_path = path
+        chosen = resolve_dialect(dialect)
+        if chosen and is_dialect_marked(path.read_text()):
+            inspect_path = Path(tempfile.mkstemp(suffix=path.suffix)[1])
+            inspect_path.write_text(apply_dialect(read_source(path), chosen))
+        try:
+            module = fortran_parser.parse_source(
+                inspect_path, ExposeConfig(functions=list(functions))
+            )
+        except ValueError as exc:
+            hint = ""
+            if not chosen and is_dialect_marked(path.read_text()):
+                hint = (
+                    "\nThe file looks dialect-marked (CS/CD prefixes on both "
+                    "copies of every line). Pass --dialect cs or --dialect cd."
+                )
+            raise click.ClickException(f"{exc}{hint}") from exc
+
     else:
         raise click.ClickException(f"Unrecognized native source: {path} (detected language: {lang}).")
 

{nativegate-0.1.6 → nativegate-0.1.8}/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.6 → nativegate-0.1.8}/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.6 → nativegate-0.1.8}/nativegate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nativegate
-Version: 0.1.6
+Version: 0.1.8
 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

{nativegate-0.1.6 → nativegate-0.1.8}/nativegate.egg-info/SOURCES.txt

@@ -68,6 +68,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 +78,7 @@ tests/test_fortran_pipeline.py
 tests/test_gateway_gen.py
 tests/test_generated_python_is_valid.py
 tests/test_golden.py
+tests/test_inspect_dialect.py
 tests/test_invariants.py
 tests/test_ir_contract.py
 tests/test_k8s_gen.py

{nativegate-0.1.6 → nativegate-0.1.8}/pyproject.toml

@@ -13,7 +13,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nativegate"
-version = "0.1.6"
+version = "0.1.8"
 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.8/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.8/tests/test_inspect_dialect.py

@@ -0,0 +1,48 @@
+"""`inspect` speaks dialect: cd too — parity with quickstart/generate.
+
+The cli-reference/fortran-guide contract: a netlib dual-dialect file
+answers the same questions through inspect with a flag that generate
+already reads from nativegate.yaml. A marked file without the flag must
+fail with a message that names the flag, never a raw parser traceback.
+"""
+
+import textwrap
+
+from click.testing import CliRunner
+
+from nativegate import cli
+
+
+DUAL = textwrap.dedent("""\
+CS    REAL FUNCTION GAMMA(X)
+CD    DOUBLE PRECISION FUNCTION DGAMMA(X)
+CS    REAL
+CD    DOUBLE PRECISION
+     1    C,CONV,EPS
+      DGAMMA = 24.0D0
+      RETURN
+      END
+""")
+
+
+def test_inspect_with_dialect_resolves_and_parses(tmp_path):
+    src = tmp_path / "gamma.f"
+    src.write_text(DUAL)
+    result = CliRunner().invoke(
+        cli.main, ["inspect", str(src), "--function", "DGAMMA", "--dialect", "cd"]
+    )
+    assert result.exit_code == 0, result.output
+    assert "function DGAMMA(X: float) -> float" in result.output
+    # the rejected CS half stays out of the IR: no standalone GAMMA function
+    assert "function GAMMA(" not in result.output
+
+
+def test_inspect_without_dialect_names_the_flag(tmp_path):
+    src = tmp_path / "gamma.f"
+    src.write_text(DUAL)
+    result = CliRunner().invoke(
+        cli.main, ["inspect", str(src), "--function", "DGAMMA"]
+    )
+    assert result.exit_code != 0
+    assert "--dialect cs" in result.output and "--dialect cd" in result.output
+    assert "Traceback" not in result.output