cobol-parser 3.3.1__tar.gz → 3.3.2__tar.gz

{cobol_parser-3.3.1/cobol_parser.egg-info → cobol_parser-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobol-parser
-Version: 3.3.1
+Version: 3.3.2
 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

{cobol_parser-3.3.1 → cobol_parser-3.3.2/cobol_parser.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cobol-parser
-Version: 3.3.1
+Version: 3.3.2
 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

{cobol_parser-3.3.1 → cobol_parser-3.3.2}/cobol_parser.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ cobolparser/profiling.py
 cobolparser/py.typed
 cobolparser/scan.py
 cobolparser/analysis/__init__.py
+cobolparser/analysis/_abend.py
 cobolparser/analysis/_cics.py
 cobolparser/analysis/_files.py
 cobolparser/analysis/_names.py

{cobol_parser-3.3.1 → cobol_parser-3.3.2}/cobolparser/__init__.py

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

cobol_parser-3.3.2/cobolparser/analysis/_abend.py

@@ -0,0 +1,25 @@
+"""Static CALLs of abend services that never return to the caller."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ..models.statements.call import CallStatement
+
+#: IBM abend services that end the run unit and never return: Language
+#: Environment's CEE3ABD ("CEE3ABD does not return", ``le_signatures``) and
+#: the COBOL library's ILBOABN0. Site-specific abend modules (``ABEND``,
+#: ``CKRABEND``) are left out: whether they return is not known here.
+NON_RETURNING_ABEND_PROGRAMS = frozenset({"CEE3ABD", "ILBOABN0"})
+
+
+def abend_call_target(stmt: Any) -> str | None:
+    """The abend service *stmt* CALLs statically, or None.
+
+    Only a literal ``CALL 'CEE3ABD'`` counts: a dynamic CALL through a data
+    name may name any program at run time.
+    """
+    if not isinstance(stmt, CallStatement) or stmt.is_dynamic:
+        return None
+    target = (stmt.called_program or "").strip().strip("'\"").upper()
+    return target if target in NON_RETURNING_ABEND_PROGRAMS else None

{cobol_parser-3.3.1 → cobol_parser-3.3.2}/cobolparser/analysis/move_type_checker.py

@@ -510,14 +510,14 @@ def _classify_picture(pic: PictureClause) -> DataCategory:
 
     if has_edit_chars:
         # Test symbols on pattern_no_reps: the 9 in a repeat count such as
-        # X(9)BX(9) is not a digit position.
-        # Numeric-edited: contains 9s alongside editing characters
-        if "9" in pattern_no_reps:
-            return DataCategory.NUMERIC_EDITED
-        # Alphanumeric-edited: X with editing chars
+        # X(9)BX(9) is not a digit position. An edited picture holding an
+        # X or an A is alphanumeric-edited even when it also holds 9s
+        # (PIC XXB99, 99/XX, A9B9): only numeric editing symbols with 9s
+        # make an item numeric-edited (IBM Language Reference, "PICTURE
+        # clause editing").
         if "X" in pattern_no_reps or "A" in pattern_no_reps:
             return DataCategory.ALPHANUMERIC_EDITED
-        return DataCategory.NUMERIC_EDITED  # default for edited
+        return DataCategory.NUMERIC_EDITED
 
     # Pure numeric: only S, 9, V, P and grouping digits
     if _PIC_NUMERIC_ONLY_RE.match(pattern):

{cobol_parser-3.3.1 → cobol_parser-3.3.2}/cobolparser/analysis/program_flow/models.py

@@ -77,6 +77,9 @@ class FlowNode:
     #: EXEC CICS RETURN / XCTL / ABEND: leaves the program, at least when
     #: it succeeds (one with RESP / NOHANDLE may also fall through).
     has_cics_exit: bool = False
+    #: A static CALL of a Language Environment abend service that never
+    #: returns (``CALL 'CEE3ABD'``, ``CALL 'ILBOABN0'``): ends the program.
+    has_abend_call: bool = False
     #: A SORT/MERGE ``RETURN sd-file`` (reads the next sorted record) --
     #: not a program terminator, unlike the four flags above.
     has_return: bool = False
@@ -124,6 +127,8 @@ class FlowNode:
             result["has_exit_program"] = True
         if self.has_cics_exit:
             result["has_cics_exit"] = True
+        if self.has_abend_call:
+            result["has_abend_call"] = True
         if self.has_return:
             result["has_return"] = True
         if self.has_exit_section:

{cobol_parser-3.3.1 → cobol_parser-3.3.2}/cobolparser/analysis/program_flow/scanner.py

@@ -32,6 +32,7 @@ from ...models.statements.misc import (
     SortStatement,
     XmlJsonStatement,
 )
+from .._abend import abend_call_target
 from .._cics import cics_exit_kind, cics_terminator_kind
 from .._procedures import ProcedureIndex, branch_terminates, enclosing_section
 from .condition_text import render_condition_text
@@ -337,6 +338,13 @@ class ProcedureScanner:
             elif isinstance(stmt, CallStatement):
                 node.call_count += 1
                 self._collector.process_call(stmt, proc_name)
+                abend_target = abend_call_target(stmt)
+                if abend_target is not None:
+                    node.has_abend_call = True
+                    self._exit_points.add(proc_name)
+                    self._record_exit_statement(
+                        node, f"CALL '{abend_target}'", stmt.location
+                    )
                 # Queue exception handler branches for nested flow
                 push_sequential(
                     [
@@ -678,8 +686,9 @@ class ProcedureScanner:
         reached: STOP RUN (not STOP 'literal', which merely halts pending
         operator action), GOBACK, EXIT PROGRAM, a non-DEPENDING GO TO --
         including the alterable ``GO TO.`` with no operand, which always
-        transfers to whatever an ALTER last set it to -- or EXEC CICS
-        RETURN / XCTL / ABEND (see ``_cics``). Mirrors
+        transfers to whatever an ALTER last set it to -- EXEC CICS
+        RETURN / XCTL / ABEND (see ``_cics``), or a static CALL of a
+        non-returning abend service (``abend_call_target``, #817). Mirrors
         DeadCodeAnalyzer._is_terminator, kept independent per this package's
         existing collaborator architecture. An exhaustive IF/EVALUATE whose
         every arm terminates counts too (``_procedures.branch_terminates``).
@@ -690,6 +699,8 @@ class ProcedureScanner:
             return True
         if isinstance(stmt, GobackStatement):
             return True
+        if abend_call_target(stmt) is not None:
+            return True
         if isinstance(stmt, StopStatement):
             return stmt.stop_type == "RUN"
         if isinstance(stmt, ExitStatement):

{cobol_parser-3.3.1 → cobol_parser-3.3.2}/cobolparser/analysis/recursion_risk.py

@@ -227,6 +227,7 @@ class _FlowIndex:
                 or node.has_goback
                 or node.has_exit_program
                 or node.has_cics_exit
+                or node.has_abend_call
             ):
                 return True
             if not self.escape_targets.get(name, set()) <= component:

{cobol_parser-3.3.1 → cobol_parser-3.3.2}/cobolparser/analysis/xref.py

@@ -34,6 +34,7 @@ import re
 from dataclasses import dataclass, field
 from typing import Any
 
+from .._literals import QUOTED_LITERAL_RE
 from ..dialects.ibm_enterprise import IBMEnterpriseCobol
 from ..lexer import CobolLexer
 from ..models.ast_base import ASTNode, SourceLocation
@@ -500,6 +501,10 @@ def _split_operand(text: str) -> tuple[set[str], set[str], set[str], bool]:
     """
     if not text:
         return set(), set(), set(), True
+    # A literal's text is no operand: `MOVE "TEST(S) FAILED" TO X` read S as a
+    # subscript (NIST CCVS85, every program), since the parentheses were
+    # split off before the literal was dropped.
+    text = QUOTED_LITERAL_RE.sub(" ", text)
     # DFHRESP(cond) / DFHVALUE(cvda): the argument is no subscript (#594).
     text = strip_translator_arguments(text)
 

{cobol_parser-3.3.1 → cobol_parser-3.3.2}/cobolparser/lexer.py

@@ -2731,15 +2731,70 @@ class _CobolLexerPure:
                 ):
                     end += 1
             if end - index > 1 and not self._after_picture(merged):
-                text = "".join(t.value or "" for t in tokens[index:end])
-                if self._TEMPLATE_NAME_RE.fullmatch(text):
-                    merged.append(Token(TokenType.IDENTIFIER, text, token.location))
+                span = self._template_name_span(tokens, index, end)
+                if span is not None:
+                    start, stop = span
+                    text = "".join(t.value or "" for t in tokens[start:stop])
+                    merged.extend(tokens[index:start])
+                    merged.append(
+                        Token(TokenType.IDENTIFIER, text, tokens[start].location)
+                    )
+                    merged.extend(tokens[stop:end])
                     index = end
                     continue
             merged.extend(tokens[index:end])
             index = end
         tokens[:] = merged
 
+    def _template_name_span(
+        self, tokens: list[Token], index: int, end: int
+    ) -> tuple[int, int] | None:
+        """The ``[start, stop)`` slice of the run ``tokens[index:end]`` that
+        spells a placeholder name, or None.
+
+        The run may carry a condition's own parentheses abutting the name:
+        ``IF (FLG-(TESTVAR1)-NOT-OK`` / ``OR FLG-(TESTVAR1)-BLANK)``. Those
+        leading '(' and trailing ')' tokens are peeled off, fewest first,
+        so a placeholder that ends the name (``WS-(SFX)``) keeps its ')'.
+        A reserved word the '(' abuts (``NOT(``, ``AND(``, ``UNTIL(``, #814)
+        is peeled off first: it is never part of the name.
+        """
+        if (
+            end - index > 2
+            and tokens[index + 1].type == TokenType.LEFT_PAREN
+            and self._is_reserved_word(tokens[index])
+        ):
+            index += 1
+        leading = 0
+        while index + leading < end and tokens[index + leading].type == (
+            TokenType.LEFT_PAREN
+        ):
+            leading += 1
+        trailing = 0
+        while end - trailing > index and tokens[end - trailing - 1].type == (
+            TokenType.RIGHT_PAREN
+        ):
+            trailing += 1
+        for peel_left in range(leading + 1):
+            for peel_right in range(trailing + 1):
+                start, stop = index + peel_left, end - peel_right
+                if stop - start < 2:
+                    continue
+                text = "".join(t.value or "" for t in tokens[start:stop])
+                if self._TEMPLATE_NAME_RE.fullmatch(text):
+                    return start, stop
+        return None
+
+    @staticmethod
+    def _is_reserved_word(token: Token) -> bool:
+        """Whether *token* is a COBOL reserved word (a keyword token)."""
+        value = token.value or ""
+        return (
+            token.type != TokenType.IDENTIFIER
+            and value.isalpha()
+            and token.type.name == value.upper().replace("-", "_")
+        )
+
     @staticmethod
     def _after_picture(merged: list[Token]) -> bool:
         """Whether the next token is a PICTURE string (``PIC [IS] ...``)."""
@@ -2781,8 +2836,9 @@ class _CobolLexerPure:
         A '#' or '@' that abuts a word (``WS-#CPT``, ``@ADDR``) is a letter
         of that name in some shops' dialects; it is glued into one
         IDENTIFIER rather than dropped, so every reference to the name stays
-        the same name. A declared PICTURE currency symbol (``CURRENCY SIGN
-        IS 'EUR' WITH PICTURE SYMBOL '#'``) becomes CURRENCY.
+        the same name, whether or not that character is also a declared
+        PICTURE currency symbol. Otherwise a declared currency symbol
+        (``CURRENCY SIGN IS 'EUR' WITH PICTURE SYMBOL '#'``) becomes CURRENCY.
 
         A single linear pass, shared verbatim by the Cython fast path, which
         inherits this method.
@@ -2796,9 +2852,17 @@ class _CobolLexerPure:
         in_exec = False
         # Whether kept[-1] is a name already glued around a '#' / '@'.
         glued = False
+        # Whether *token* belongs to a PICTURE string: the run of abutting
+        # tokens right after PIC / PICTURE [IS]. Only there is a declared
+        # currency symbol one (#809).
+        in_picture = False
         count = len(tokens)
         for index, token in enumerate(tokens):
             ttype = token.type
+            if in_picture and not self._abuts(tokens[index - 1], token):
+                in_picture = False
+            if not in_picture and self._after_picture(kept):
+                in_picture = True
             if ttype == TokenType.EXEC:
                 in_exec = True
             elif ttype == TokenType.END_EXEC:
@@ -2821,11 +2885,14 @@ class _CobolLexerPure:
                 continue
             line = token.location.line if token.location else 0
             if ttype == TokenType.SQL_NAME_CHAR:
-                if token.value in self._currency_symbols:
+                if in_picture and token.value in self._currency_symbols:
                     token.type = TokenType.CURRENCY
                     kept.append(token)
                     glued = False
                     continue
+                # Outside a PICTURE string a currency symbol means nothing,
+                # so ``WS-#N`` stays one name even when '#' is the PICTURE
+                # currency symbol (#809).
                 prev = kept[-1] if kept else None
                 nxt = tokens[index + 1] if index + 1 < count else None
                 if (
@@ -2851,6 +2918,11 @@ class _CobolLexerPure:
                     glued = True
                     glued_names.setdefault(token.value, []).append(line)
                     continue
+                if token.value in self._currency_symbols:
+                    token.type = TokenType.CURRENCY
+                    kept.append(token)
+                    glued = False
+                    continue
             dropped.setdefault(token.value, []).append(line)
             glued = False
         tokens[:] = kept

{cobol_parser-3.3.1 → cobol_parser-3.3.2}/cobolparser/mcp/tools.py

@@ -3285,7 +3285,11 @@ def _control_flow_notes(nodes: list[Any]) -> list[str]:
     ends = [
         n
         for n in nodes
-        if n.has_stop_run or n.has_goback or n.has_exit_program or n.has_cics_exit
+        if n.has_stop_run
+        or n.has_goback
+        or n.has_exit_program
+        or n.has_cics_exit
+        or n.has_abend_call
     ]
     if not ends:
         notes.append(

{cobol_parser-3.3.1 → cobol_parser-3.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cobol-parser"
-version = "3.3.1"
+version = "3.3.2"
 description = "A comprehensive COBOL parser for Python with IBM Enterprise COBOL focus"
 readme = "README.md"
 requires-python = ">=3.11"