agent-codinglanguage-mapper 1.0.0__py3-none-any.whl

agent_codinglanguage_mapper/adapters/delphi_frontend/source_reader.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def read_source_text(path: Path) -> str:
+    data = path.read_bytes()
+    if data.startswith(b'\xff\xfe') or data.startswith(b'\xfe\xff'):
+        text = data.decode('utf-16')
+    elif data.startswith(b'\xef\xbb\xbf'):
+        text = data.decode('utf-8-sig')
+    else:
+        try:
+            text = data.decode('utf-8')
+        except UnicodeDecodeError:
+            text = data.decode('latin-1')
+    return text.replace('\r\n', '\n').replace('\r', '\n')

agent_codinglanguage_mapper/adapters/delphi_frontend/workspace.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from .consts import AttributeName
+from .nodes import SyntaxNode
+from .parser import DelphiParser
+from .semantic import Scope, ScopeKind, SymbolIndex
+from .semantic_builder import SemanticBuilder, SemanticModel
+
+
+@dataclass
+class WorkspaceSemanticResult:
+    models: dict[str, SemanticModel]
+    index: SymbolIndex
+
+
+def build_workspace_semantics(
+    sources: dict[str, str],
+    *,
+    include_paths: Iterable[str] = (),
+    defines: Iterable[str] = (),
+    preprocessor_options=None,
+    collect_references: bool = True,
+) -> WorkspaceSemanticResult:
+    parser = DelphiParser(
+        include_paths=include_paths,
+        defines=defines,
+        preprocessor_options=preprocessor_options,
+    )
+    roots: dict[str, SyntaxNode] = {}
+    for file_name, text in sources.items():
+        result = parser.parse(text, file_name, build_semantic=False)
+        roots[file_name] = result.root
+
+    return build_workspace_semantics_from_roots(
+        roots,
+        collect_references=collect_references,
+    )
+
+
+def build_workspace_semantics_from_roots(
+    roots: dict[str, SyntaxNode],
+    *,
+    collect_references: bool = True,
+) -> WorkspaceSemanticResult:
+    """Build project semantics from syntax roots that have already been parsed."""
+
+    index = SymbolIndex()
+    scopes: dict[str, Scope] = {}
+    for file_name, root in roots.items():
+        unit_name = root.get_attribute(AttributeName.anName) or file_name
+        unit_scope = Scope(kind=ScopeKind.UNIT, name=unit_name)
+        index.register_unit(unit_name, unit_scope, index_symbols=False)
+        scopes[file_name] = unit_scope
+
+    builder = SemanticBuilder(collect_references=collect_references)
+    for file_name, root in roots.items():
+        builder.declare(root, index=index, unit_scope=scopes[file_name], reset_state=False)
+
+    models: dict[str, SemanticModel] = {}
+    for file_name, root in roots.items():
+        model = builder.resolve(root, scopes[file_name])
+        models[file_name] = model
+
+    return WorkspaceSemanticResult(models=models, index=index)