cobol-parser 3.2.1__tar.gz → 3.3.0__tar.gz

{cobol_parser-3.2.1/cobol_parser.egg-info → cobol_parser-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobol-parser
-Version: 3.2.1
+Version: 3.3.0
 Summary: A comprehensive COBOL parser for Python with IBM Enterprise COBOL focus
 Author-email: Samuel Dion <sam94dion@gmail.com>
 License: AGPL-3.0-or-later
@@ -28,7 +28,7 @@ Requires-Dist: jcl-parser>=2.0.0; extra == "jcl"
 Provides-Extra: pl1
 Requires-Dist: landparty-pl1-parser>=2.0.0; extra == "pl1"
 Provides-Extra: hlasm
-Requires-Dist: hlasmparser>=0.2.0; extra == "hlasm"
+Requires-Dist: hlasm-parser>=0.2.2; extra == "hlasm"
 Provides-Extra: mcp
 Requires-Dist: mcp<2,>=1.10; extra == "mcp"
 Provides-Extra: dev
@@ -289,8 +289,8 @@ python -m black .
 python -m mypy cobolparser/
 ```
 
-CI is currently switched off (`.github/workflows/ci.yml` is commented out), so
-run lint, types and the full suite locally before pushing. Measure coverage on
+CI runs only on manual dispatch (`.github/workflows/ci.yml` has no push or PR
+trigger), so run lint, types and the full suite locally before pushing. Measure coverage on
 the pure-Python build: with `COBOLPARSER_ACCEL=1`, coverage.py cannot see the
 code the compiled modules replace. Test layout and markers:
 [.okf/tests.md](.okf/tests.md).

{cobol_parser-3.2.1 → cobol_parser-3.3.0}/README.md

@@ -239,8 +239,8 @@ python -m black .
 python -m mypy cobolparser/
 ```
 
-CI is currently switched off (`.github/workflows/ci.yml` is commented out), so
-run lint, types and the full suite locally before pushing. Measure coverage on
+CI runs only on manual dispatch (`.github/workflows/ci.yml` has no push or PR
+trigger), so run lint, types and the full suite locally before pushing. Measure coverage on
 the pure-Python build: with `COBOLPARSER_ACCEL=1`, coverage.py cannot see the
 code the compiled modules replace. Test layout and markers:
 [.okf/tests.md](.okf/tests.md).

{cobol_parser-3.2.1 → cobol_parser-3.3.0/cobol_parser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobol-parser
-Version: 3.2.1
+Version: 3.3.0
 Summary: A comprehensive COBOL parser for Python with IBM Enterprise COBOL focus
 Author-email: Samuel Dion <sam94dion@gmail.com>
 License: AGPL-3.0-or-later
@@ -28,7 +28,7 @@ Requires-Dist: jcl-parser>=2.0.0; extra == "jcl"
 Provides-Extra: pl1
 Requires-Dist: landparty-pl1-parser>=2.0.0; extra == "pl1"
 Provides-Extra: hlasm
-Requires-Dist: hlasmparser>=0.2.0; extra == "hlasm"
+Requires-Dist: hlasm-parser>=0.2.2; extra == "hlasm"
 Provides-Extra: mcp
 Requires-Dist: mcp<2,>=1.10; extra == "mcp"
 Provides-Extra: dev
@@ -289,8 +289,8 @@ python -m black .
 python -m mypy cobolparser/
 ```
 
-CI is currently switched off (`.github/workflows/ci.yml` is commented out), so
-run lint, types and the full suite locally before pushing. Measure coverage on
+CI runs only on manual dispatch (`.github/workflows/ci.yml` has no push or PR
+trigger), so run lint, types and the full suite locally before pushing. Measure coverage on
 the pure-Python build: with `COBOLPARSER_ACCEL=1`, coverage.py cannot see the
 code the compiled modules replace. Test layout and markers:
 [.okf/tests.md](.okf/tests.md).

{cobol_parser-3.2.1 → cobol_parser-3.3.0}/cobol_parser.egg-info/SOURCES.txt

@@ -95,6 +95,12 @@ cobolparser/core/exceptions.py
 cobolparser/core/interfaces.py
 cobolparser/core/registry.py
 cobolparser/core/token_stream.py
+cobolparser/definitions/__init__.py
+cobolparser/definitions/_asm.py
+cobolparser/definitions/bms.py
+cobolparser/definitions/csd.py
+cobolparser/definitions/ddl.py
+cobolparser/definitions/ims.py
 cobolparser/dialects/__init__.py
 cobolparser/dialects/ibm_enterprise.py
 cobolparser/dialects/le_signatures.py

{cobol_parser-3.2.1 → cobol_parser-3.3.0}/cobol_parser.egg-info/requires.txt

@@ -18,7 +18,7 @@ sphinx-rtd-theme>=1.3.0
 cython>=3.0
 
 [hlasm]
-hlasmparser>=0.2.0
+hlasm-parser>=0.2.2
 
 [jcl]
 jcl-parser>=2.0.0

{cobol_parser-3.2.1 → cobol_parser-3.3.0}/cobolparser/__init__.py

@@ -231,7 +231,7 @@ from .scan import (
 CobolParseError = ParseError
 
 # Version info
-__version__ = "3.2.1"  # x-release-please-version
+__version__ = "3.3.0"  # x-release-please-version
 __author__ = "Samuel Dion"
 __license__ = "AGPL-3.0-or-later"
 

{cobol_parser-3.2.1 → cobol_parser-3.3.0}/cobolparser/analysis/_sql_flow.py

@@ -181,8 +181,16 @@ def host_var_name(raw: str) -> str:
     return " OF ".join(reversed(parts))
 
 
+#: A DB2 delimited identifier that is an ordinary name once unquoted.
+_SIMPLE_DELIMITED_RE = re.compile(r'"([A-Z#@$][A-Z0-9_#@$]*)"')
+
+
 def _normalize(sql: str) -> str:
     text = _STRING_RE.sub("''", sql.upper())
+    # ``"TAB4"`` is the table TAB4, as ExecSQLStatement.tables reads it. A
+    # delimited name that is no ordinary name (``"MY TAB"``) keeps its
+    # quotes, so it is skipped with a caveat rather than cut at its blank.
+    text = _SIMPLE_DELIMITED_RE.sub(r"\1", text)
     return " ".join(text.split())
 
 
@@ -306,8 +314,34 @@ def _columns_in(expr: str) -> list[tuple[str | None, str]]:
     return out
 
 
+def _skipped_correlation(piece: str) -> str | None:
+    """The correlation name after a parenthesised FROM item (a sub-select,
+    ``TABLE(...)`` or ``FINAL TABLE (...)``): ``(...) AS X`` -> ``X``."""
+    if "(" not in piece:
+        return None
+    _inner, after = _balanced(piece, piece.index("("))
+    words = piece[after:].split()
+    if words and words[0] == "AS":
+        words = words[1:]
+    if words:
+        # ``AS T(V)``: a correlation name followed by its column list.
+        words[0] = words[0].split("(", 1)[0]
+    if (
+        words
+        and words[0] not in _SQL_WORDS
+        and re.fullmatch(r"[A-Z0-9_#@$-]+", words[0])
+    ):
+        return words[0]
+    return None
+
+
 def _from_tables(from_body: str) -> tuple[dict[str, str], list[str], list[str]]:
-    """alias -> table, the table list in order, and caveats."""
+    """alias -> table, the table list in order, and caveats.
+
+    A FROM item that is not traced (a sub-select, a table function, a
+    data-change reference) maps its correlation name to ``""``, so a column
+    qualified by it is not mistaken for a column of a table of that name.
+    """
     caveats: list[str] = []
     aliases: dict[str, str] = {}
     tables: list[str] = []
@@ -318,16 +352,31 @@ def _from_tables(from_body: str) -> tuple[dict[str, str], list[str], list[str]]:
         piece = re.split(r"\bON\b", piece, maxsplit=1)[0].strip()
         if not piece:
             continue
+        skipped = None
         if piece.startswith("("):
-            caveats.append("a sub-select in FROM is not traced")
-            continue
-        if re.match(r"(?:FINAL|NEW|OLD)\s+TABLE\s*\(", piece):
+            skipped = "a sub-select in FROM is not traced"
+        elif re.match(r"(?:FINAL|NEW|OLD)\s+TABLE\s*\(", piece):
             # SELECT ... FROM FINAL TABLE (INSERT ...): the rows come from
             # the data-change statement inside, not from a table named FINAL.
-            caveats.append("a data-change table reference in FROM is not traced")
-            continue
-        if re.match(r"TABLE\s*\(", piece):
-            caveats.append("a table function in FROM is not traced")
+            skipped = "a data-change table reference in FROM is not traced"
+        elif re.match(r"TABLE\s*\(", piece):
+            skipped = "a table function in FROM is not traced"
+        elif re.match(r"LATERAL\s*\(", piece):
+            skipped = "a LATERAL sub-select in FROM is not traced"
+        elif re.match(r"(?:XMLTABLE|JSON_TABLE)\s*\(", piece):
+            skipped = "an XMLTABLE / JSON_TABLE item in FROM is not traced"
+        elif re.match(r"UNNEST\s*\(", piece):
+            skipped = "an UNNEST item in FROM is not traced"
+        elif re.match(r"\S*['\"(]", piece):
+            # Whatever the item is, a first word holding ``(`` or a quote
+            # is never a table name (a delimited ``"MY TAB"`` is not read).
+            skipped = "a FROM item that is not a table name is not traced"
+        if skipped is not None:
+            caveats.append(skipped)
+            name = _skipped_correlation(piece)
+            # Even with no correlation name the item's columns are in scope,
+            # so an unqualified column may come from it: "" marks that.
+            aliases[name or ""] = ""
             continue
         # ``BANK . ACCOUNT`` is one qualified name: join it before splitting
         # the piece into table and correlation name.
@@ -349,11 +398,14 @@ def _resolve_column(
 ) -> list[tuple[str, str, bool]]:
     if qualifier is not None:
         table = aliases.get(qualifier)
-        if table is not None:
+        if table:
             return [(table, column, True)]
-        return [(qualifier, column, False)]
+        # An untraced FROM item's correlation name (""), or a qualifier that
+        # names no FROM item: no table of that name is invented.
+        return []
+    untraced = "" in aliases.values()
     if len(tables) == 1:
-        return [(tables[0], column, True)]
+        return [(tables[0], column, not untraced)]
     return [(table, column, False) for table in tables]
 
 
@@ -405,6 +457,11 @@ def _select_flows(
             result.caveats.append("SELECT * INTO is not traced column by column")
             continue
         for qualifier, column in _columns_in(expr):
+            if qualifier is not None and qualifier not in aliases:
+                result.caveats.append(
+                    f"{qualifier}.{column} names no table or correlation name "
+                    "in FROM; not traced"
+                )
             for table, col, exact in _resolve_column(
                 qualifier, column, aliases, tables
             ):

{cobol_parser-3.2.1 → cobol_parser-3.3.0}/cobolparser/analysis/boundary_inventory.py

@@ -814,11 +814,20 @@ class BoundaryInventoryAnalyzer:
                     f"{category} {record_name}: record not resolvable in layout index"
                 )
                 report.unresolved.extend(gaps)
+            # The FILE STATUS of the FD the record belongs to: a WRITE or
+            # REWRITE sets it like any other operation on the file.
+            fd_file = record.get_metadata("fd_file_name") if record else None
+            write_facts = index.file_facts(str(fd_file)) if fd_file else None
             report.boundaries.append(
                 Boundary(
                     ref=ref(category, record_name.upper()),
                     direction="OUT",
                     record_names=record_names,
+                    status_field=(
+                        write_facts.file_status_field
+                        if write_facts is not None
+                        else None
+                    ),
                     handlers=handlers,
                     unresolved=gaps,
                 )

{cobol_parser-3.2.1 → cobol_parser-3.3.0}/cobolparser/analysis/constraints.py

@@ -222,6 +222,13 @@ _RELATIONAL_TEXT_OP_CANON: dict[str, str] = {
     "<": "lt",
 }
 _BARE_IDENTIFIER_RE = re.compile(r"^[A-Za-z][A-Za-z0-9-]*$")
+# A class or sign test in relational text: ``LK-ID IS NOT NUMERIC``.
+_CLASS_TEXT_RE = re.compile(
+    r"^([A-Za-z][A-Za-z0-9-]*)\s+(?:IS\s+)?(NOT\s+)?"
+    r"(NUMERIC|ALPHABETIC(?:\s*-\s*(?:UPPER|LOWER))?|POSITIVE|NEGATIVE"
+    r"|ZEROES|ZEROS|ZERO)$",
+    re.IGNORECASE,
+)
 
 
 @dataclass(frozen=True)
@@ -427,12 +434,61 @@ class TransferSite:
         }
 
 
+#: A file statement's handler clauses that nest another statement: the
+#: nested one runs only when the outer statement takes that clause.
+_HANDLER_CLAUSES = (
+    "invalid_key_clause",
+    "not_invalid_key_clause",
+    "at_end_clause",
+    "not_at_end_clause",
+)
+
+
+@dataclass(frozen=True)
+class StatementSite:
+    """Where one boundary statement sits (keyed by its line in
+    `ConstraintReport.statement_sites`): its paragraph, the branch arms
+    enclosing it there (`BranchConstraints.enclosing`'s shape), and the
+    handler clauses of other statements it is nested in, outermost first,
+    as ``(outer statement line, clause)`` with the clause one of
+    ``INVALID_KEY``, ``NOT_INVALID_KEY``, ``AT_END``, ``NOT_AT_END``.
+
+    The planner's status families read it to pin the path to the statement
+    they fail: a READ that runs only for one transaction code, or a WRITE
+    that runs only in another READ's INVALID KEY clause."""
+
+    paragraph: str
+    enclosing: tuple[tuple[str, str], ...] = ()
+    handlers: tuple[tuple[int, str], ...] = ()
+    #: A READ that can return FILE STATUS "02" (another record has the same
+    #: alternate key): one by ``KEY IS`` an ALTERNATE RECORD KEY WITH
+    #: DUPLICATES. A READ by the prime key never can; a sequential one can
+    #: when its key of reference is such a key, which is not tracked.
+    duplicate_key: bool = False
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "paragraph": self.paragraph,
+            "enclosing": [list(pair) for pair in self.enclosing],
+            "handlers": [list(pair) for pair in self.handlers],
+            "duplicate_key": self.duplicate_key,
+        }
+
+
 @dataclass
 class ConstraintReport:
     branches: list[BranchConstraints] = field(default_factory=list)
     sequence_constraints: list[SequenceConstraint] = field(default_factory=list)
     unsupported: list[str] = field(default_factory=list)
     transfer_sites: list[TransferSite] = field(default_factory=list)
+    #: Uppercased data-name -> the two-character codes the program tests it
+    #: against (``IF WS-FS = '23'``, an 88 under it, ``EVALUATE WS-FS WHEN
+    #: '02'``), sorted. Read for FILE STATUS fields by the planner's
+    #: file-status family; never a branch constraint (a status field is
+    #: set by the file operation, not by data).
+    status_tests: dict[str, list[str]] = field(default_factory=dict)
+    #: Boundary statement line -> its `StatementSite`.
+    statement_sites: dict[int, StatementSite] = field(default_factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
         return {
@@ -440,6 +496,11 @@ class ConstraintReport:
             "sequence_constraints": [s.to_dict() for s in self.sequence_constraints],
             "unsupported": list(self.unsupported),
             "transfer_sites": [t.to_dict() for t in self.transfer_sites],
+            "status_tests": {k: list(v) for k, v in self.status_tests.items()},
+            "statement_sites": {
+                str(line): site.to_dict()
+                for line, site in sorted(self.statement_sites.items())
+            },
         }
 
 
@@ -473,6 +534,9 @@ class ConstraintExtractor:
 
         fed_names = _boundary_fed_names(boundary_report)
         fed_names.update(name.upper() for name in extra_fed_names)
+        index.named_constants = _named_constants(ast, index)
+        report.status_tests = _status_tests(ast, procedure, index)
+        report.statement_sites = _statement_sites(procedure, boundary_report, index)
         eof_flags = _collect_eof_flags(ast)
         carriers = _Carriers(ast, procedure, index, fed_names)
 
@@ -1022,8 +1086,22 @@ def _extract_class_or_sign(
     origin: str,
     unsupported: list[str],
 ) -> FieldConstraint | None:
-    effective_negate = negate != is_not
     name = expr.left_operand if isinstance(expr.left_operand, str) else ""
+    return _class_or_sign_constraint(
+        name, class_word, negate != is_not, index, fed_names, origin, unsupported
+    )
+
+
+def _class_or_sign_constraint(
+    name: str,
+    class_word: str,
+    effective_negate: bool,
+    index: ProgramLayoutIndex,
+    fed_names: set[str],
+    origin: str,
+    unsupported: list[str],
+) -> FieldConstraint | None:
+    """``name [NOT] <class or sign word>`` as one constraint, or None."""
     if not name.strip():
         unsupported.append(f"{origin}: class/sign condition missing operand")
         return None
@@ -1302,8 +1380,18 @@ def _build_relational_constraint(
     if not left_text:
         unsupported.append(f"{origin}: comparison missing left operand")
         return None
+    left_text = _fold_cics_value(left_text)
+    right_text = _fold_cics_value(right_text) if right_text else right_text
     left_field = index.resolve(left_text)
     right_field = index.resolve(right_text) if right_text else None
+    if left_field is not None and right_field is not None:
+        # A WORKING-STORAGE item the program never changes is its VALUE.
+        right_constant = _constant_of(right_field, index)
+        left_constant = _constant_of(left_field, index)
+        if right_constant is not None and left_constant is None:
+            right_text, right_field = right_constant, None
+        elif left_constant is not None and right_constant is None:
+            left_text, left_field = left_constant, None
 
     if left_field is not None and right_field is not None:
         if site is not None:
@@ -1559,6 +1647,21 @@ def _parse_relational_text(
                 quoted_operands=False,
             )
 
+    class_match = _CLASS_TEXT_RE.match(text)
+    if class_match:
+        # ``WHEN LK-ID NOT NUMERIC`` / ``WHEN WS-AMT IS POSITIVE``: the class
+        # and sign tests the IF path models from the condition tree.
+        name, is_not, class_word = class_match.groups()
+        return _class_or_sign_constraint(
+            name,
+            re.sub(r"\s+", "", class_word.upper()),
+            bool(is_not),
+            index,
+            fed_names,
+            origin,
+            unsupported,
+        )
+
     if _BARE_IDENTIFIER_RE.match(text):
         return _extract_condition_name_value(
             text, False, index, fed_names, origin, unsupported
@@ -1890,6 +1993,174 @@ def _holds_losslessly(carrier: Any, source: Any) -> bool:
     return False
 
 
+#: ``DFHRESP(condition)`` values (the EIBRESP code the CICS translator
+#: substitutes), for a comparison of a RESP field against one.
+_DFHRESP_VALUES: dict[str, int] = {
+    "NORMAL": 0,
+    "ERROR": 1,
+    "RDATT": 2,
+    "WRBRK": 3,
+    "EOF": 4,
+    "EODS": 5,
+    "EOC": 6,
+    "INBFMH": 7,
+    "ENDINPT": 8,
+    "NONVAL": 9,
+    "NOSTART": 10,
+    "TERMIDERR": 11,
+    "FILENOTFOUND": 12,
+    "DSIDERR": 12,
+    "NOTFND": 13,
+    "DUPREC": 14,
+    "DUPKEY": 15,
+    "INVREQ": 16,
+    "IOERR": 17,
+    "NOSPACE": 18,
+    "NOTOPEN": 19,
+    "ENDFILE": 20,
+    "ILLOGIC": 21,
+    "LENGERR": 22,
+    "QZERO": 23,
+    "SIGNAL": 24,
+    "QBUSY": 25,
+    "ITEMERR": 26,
+    "PGMIDERR": 27,
+    "TRANSIDERR": 28,
+    "ENDDATA": 29,
+    "EXPIRED": 31,
+    "MAPFAIL": 36,
+    "INVMPSZ": 38,
+    "QIDERR": 44,
+    "SYSIDERR": 53,
+    "NOTAUTH": 70,
+    "DISABLED": 84,
+}
+_DFHRESP_RE = re.compile(r"^DFHRESP\s*\(\s*([A-Z0-9]+)\s*\)$", re.IGNORECASE)
+
+
+def _fold_cics_value(text: str) -> str:
+    """``DFHRESP(NOTFND)`` as the number the CICS translator puts there."""
+    match = _DFHRESP_RE.match(text.strip())
+    if match is None:
+        return text
+    value = _DFHRESP_VALUES.get(match.group(1).upper())
+    return text if value is None else str(value)
+
+
+#: xref roles that never change the referenced item.
+_READ_ONLY_ROLES = frozenset({"read", "condition", "subscript"})
+
+
+_TWO_CHAR_LITERAL_RE = re.compile(r"""^(['"])(.{2})\1$""")
+
+
+def _status_tests(
+    ast: CobolProgram, procedure: Any, index: ProgramLayoutIndex
+) -> dict[str, list[str]]:
+    """Every two-character literal each data item is compared with, and
+    the VALUEs of each condition-name tested, by the item's uppercased
+    leaf name (`ConstraintReport.status_tests`). Collected from IF and
+    PERFORM UNTIL comparisons and from EVALUATE subjects and selectors."""
+    found: dict[str, set[str]] = {}
+
+    def leaf(name: str) -> str | None:
+        resolved = index.resolve(name.strip())
+        if resolved is None:
+            return None
+        return resolved.spec.qualified_name.upper().rsplit(".", 1)[-1]
+
+    def add_literal(name: str, literal: object) -> None:
+        match = _TWO_CHAR_LITERAL_RE.match(str(literal or "").strip())
+        target = leaf(name) if name else None
+        if match and target:
+            found.setdefault(target, set()).add(match.group(2))
+
+    def add_condition_name(name: str) -> None:
+        values = index.condition_values(name.strip())
+        target = leaf(name)
+        if values and target:
+            found.setdefault(target, set()).update(
+                str(v) for v in values if len(str(v)) == 2
+            )
+
+    def add_text(text: str) -> None:
+        match = _RELATIONAL_TEXT_RE.match(text.strip())
+        if match:
+            add_literal(match.group(1), match.group(3).strip())
+        elif _BARE_IDENTIFIER_RE.match(text.strip()):
+            add_condition_name(text)
+
+    for expr in ast.find_all_by_type("ConditionalExpression"):
+        if not isinstance(expr, ConditionalExpression):
+            continue
+        left = expr.left_operand if isinstance(expr.left_operand, str) else ""
+        if expr.operator == "CONDITION_NAME" and left:
+            add_condition_name(left)
+        elif left:
+            add_literal(left, expr.right_operand)
+    for _, statement, _ in _walk_statements(procedure):
+        if not isinstance(statement, EvaluateStatement):
+            continue
+        subjects = statement.subjects
+        subject = subjects[0] if len(subjects) == 1 else None
+        is_true = isinstance(subject, str) and subject.strip().upper() == "TRUE"
+        for when in statement.when_clauses:
+            for selector in when.selectors:
+                if not isinstance(selector, dict):
+                    continue
+                if is_true and selector.get("type") == "Literal":
+                    add_condition_name(str(selector.get("value", "")))
+                elif is_true and selector.get("type") == "Condition":
+                    add_text(str(selector.get("text", "")))
+                elif isinstance(subject, str) and selector.get("type") == "Literal":
+                    value = str(selector.get("value", ""))
+                    if selector.get("quoted"):
+                        value = f"'{value}'"
+                    add_literal(subject, value)
+    return {name: sorted(codes) for name, codes in found.items()}
+
+
+def _named_constants(ast: CobolProgram, index: ProgramLayoutIndex) -> dict[str, str]:
+    """``{qualified name: VALUE literal}`` of every WORKING-STORAGE
+    elementary item with a literal VALUE that nothing in the program writes,
+    neither the item nor a group above it (a MOVE to the group, a READ INTO
+    it, an INITIALIZE, a CALL that may change it all count as writes)."""
+    from .xref import XrefAnalyzer
+
+    try:
+        entries = XrefAnalyzer().analyze(ast).entries
+    except Exception:  # noqa: BLE001 - best effort: no constants
+        return {}
+    changed = {
+        entry.name.upper()
+        for entry in entries
+        if any(ref.role not in _READ_ONLY_ROLES for ref in entry.references)
+    }
+    constants: dict[str, str] = {}
+    for entry in entries:
+        if entry.section != "WORKING-STORAGE" or entry.level in (None, 66, 88):
+            continue
+        resolved = index.resolve(entry.name)
+        if resolved is None or resolved.section != "working_storage":
+            continue
+        spec = resolved.spec
+        if spec.redefines or spec.subscripts or not spec.value_clause:
+            continue
+        if any(part.upper() in changed for part in (*spec.path, spec.name)):
+            continue
+        if resolved.record.name.upper() in changed:
+            continue
+        value = str(spec.value_clause).strip()
+        if not _is_literal_operand(value) or _figurative_name(value) is not None:
+            continue
+        constants[spec.qualified_name.upper()] = value
+    return constants
+
+
+def _constant_of(resolved: ResolvedField, index: ProgramLayoutIndex) -> str | None:
+    return index.named_constants.get(resolved.spec.qualified_name.upper())
+
+
 def _boundary_fed_names(report: BoundaryReport) -> set[str]:
     fed: set[str] = set()
     for boundary in report.boundaries:
@@ -2151,6 +2422,79 @@ def _record_transfer_site(
         )
 
 
+def _duplicate_key_read(statement: Any, index: ProgramLayoutIndex) -> bool:
+    if not isinstance(statement, IOReadStatement) or not statement.file_name:
+        return False
+    facts = index.file_facts(statement.file_name)
+    if facts is None:
+        return False
+    duplicates = {
+        str(key.get("key", "")).upper()
+        for key in facts.alternate_keys
+        if key.get("duplicates_allowed")
+    }
+    # A sequential READ returns "02" only when the key of reference (set by
+    # an earlier START / READ ... KEY) is such a key, which is not tracked:
+    # left out rather than guessed.
+    return bool(statement.key_name) and statement.key_name.upper() in duplicates
+
+
+def _statement_sites(
+    procedure_division: CobolDivision,
+    boundary_report: BoundaryReport,
+    index: ProgramLayoutIndex,
+) -> dict[int, StatementSite]:
+    """`StatementSite` of every boundary statement, by line (the first
+    statement on a line wins)."""
+    lines = {b.ref.line for b in boundary_report.boundaries if b.ref.line}
+    sites: dict[int, StatementSite] = {}
+    if not lines:
+        return sites
+
+    def walk(
+        paragraph: str,
+        statements: list[Any],
+        enclosing: tuple[tuple[str, str], ...],
+        handlers: tuple[tuple[int, str], ...],
+    ) -> None:
+        for statement in statements:
+            location = getattr(statement, "location", None)
+            line = location.line if location is not None else None
+            if line in lines and line not in sites:
+                sites[line] = StatementSite(
+                    paragraph,
+                    enclosing,
+                    handlers,
+                    _duplicate_key_read(statement, index),
+                )
+            is_branch = isinstance(
+                statement, (IfStatement, EvaluateStatement, SearchStatement)
+            )
+            branch_id = _branch_id(paragraph, location) if is_branch else None
+            clause_lists = {
+                id(getattr(statement, attr, None)): attr.removesuffix("_clause").upper()
+                for attr in _HANDLER_CLAUSES
+                if getattr(statement, attr, None)
+            }
+            for arm_id, nested in _nested_statement_lists(statement):
+                deeper = (
+                    enclosing + ((branch_id, arm_id),)
+                    if arm_id is not None and branch_id is not None
+                    else enclosing
+                )
+                clause = clause_lists.get(id(nested))
+                outer = (
+                    handlers + ((line, clause),)
+                    if clause is not None and line is not None and not is_branch
+                    else handlers
+                )
+                walk(paragraph, nested, deeper, outer)
+
+    for paragraph in _all_paragraphs(procedure_division):
+        walk(paragraph.paragraph_name, paragraph.statements, (), ())
+    return sites
+
+
 def _branch_id(paragraph_name: str | None, location: SourceLocation | None) -> str:
     line = location.line if location else "?"
     column = location.column if location else "?"
@@ -2164,5 +2508,6 @@ __all__ = [
     "BranchConstraints",
     "ConstraintReport",
     "TransferSite",
+    "StatementSite",
     "ConstraintExtractor",
 ]