jcl-parser 2.0.0__tar.gz → 2.0.2__tar.gz

{jcl_parser-2.0.0 → jcl_parser-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jcl-parser
-Version: 2.0.0
+Version: 2.0.2
 Summary: Parse IBM JCL (Job Control Language) scripts into Python objects
 Author-email: JCL Parser Team <team@jclparser.dev>
 License: AGPL-3.0-or-later

{jcl_parser-2.0.0 → jcl_parser-2.0.2}/jcl_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jcl-parser
-Version: 2.0.0
+Version: 2.0.2
 Summary: Parse IBM JCL (Job Control Language) scripts into Python objects
 Author-email: JCL Parser Team <team@jclparser.dev>
 License: AGPL-3.0-or-later

{jcl_parser-2.0.0 → jcl_parser-2.0.2}/jcl_parser.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ jclparser/lint/runner.py
 jclparser/plugins/__init__.py
 jclparser/plugins/base.py
 jclparser/program_profiles/__init__.py
+jclparser/program_profiles/_control.py
 jclparser/program_profiles/_invoked.py
 jclparser/program_profiles/adrdssu.py
 jclparser/program_profiles/base.py

{jcl_parser-2.0.0 → jcl_parser-2.0.2}/jclparser/__init__.py

@@ -20,7 +20,7 @@ application, for example::
 import logging as _logging
 
 # Package metadata
-__version__ = "2.0.0"  # x-release-please-version
+__version__ = "2.0.2"  # x-release-please-version
 __author__ = "JCL Parser Team"
 __description__ = "Parse IBM JCL scripts into Python objects"
 

{jcl_parser-2.0.0 → jcl_parser-2.0.2}/jclparser/_job_builder.py

@@ -131,10 +131,13 @@ class JobBuilder:
         "XMIT": "_on_xmit",
     }
 
-    def __init__(self, dialect: str = "standard") -> None:
+    def __init__(self, dialect: str = "standard", strict: bool = False) -> None:
         #: ``ParserConfig.dialect``: decides which JES control statements are
         #: interpreted (see ``jclparser.plugins.SUPPORTED_DIALECTS``).
         self.dialect = dialect
+        #: Strict parsing: a SET value over ``MAX_SYMBOL_VALUE_LENGTH`` raises
+        #: instead of being left unresolved with a warning.
+        self.strict = strict
         self.job: Job | None = None
         #: tuples: (ConditionalBlock, active_branch)
         self.conditional_stack: list[tuple[ConditionalBlock, str]] = []
@@ -437,7 +440,14 @@ class JobBuilder:
             symbols = self.job.set_statements if self.job else self.pending_sets
 
         def _record(symbol: str, value: str) -> None:
-            resolved = _resolve_set_value(value, symbols)
+            resolved = _resolve_set_value(
+                value,
+                symbols,
+                symbol=symbol,
+                line_number=stmt.line_number,
+                strict=self.strict,
+                warnings=self._warnings_sink(),
+            )
             if procedure is not None:
                 procedure.set_statements[symbol] = resolved
             elif self.job:
@@ -611,9 +621,19 @@ class JobBuilder:
                 self.pending_jes_typed.append(typed)
 
     def _on_output(self, stmt: Statement, line_num: int) -> None:
-        # OUTPUT statement - JES output descriptor; promote to typed model
+        # OUTPUT statement - JES output descriptor; promote to typed model.
+        # Coded after an EXEC it is step-level, before the first EXEC
+        # job-level (or, in a PROC body, procedure-level): DD OUTPUT=*.name
+        # resolution depends on which (#85).
+        step = self.current_step
+        procedure = self.current_procedure
+        output = OutputStatement.from_statement(
+            stmt,
+            step_name=(step.name or "") if step is not None else None,
+            procedure_name=procedure.name if procedure is not None else None,
+        )
         sink = self.job.output_statements if self.job else self.pending_outputs
-        sink.append(OutputStatement.from_statement(stmt))
+        sink.append(output)
 
     def _on_null(self, stmt: Statement, line_num: int) -> None:
         # NULL statement (//) - just ignore, used as delimiter

{jcl_parser-2.0.0 → jcl_parser-2.0.2}/jclparser/_model_factories.py

@@ -21,13 +21,22 @@ import re
 from collections.abc import Callable
 from typing import Any
 
+from .errors import JCLSyntaxError
 from .model import DDStatement, Job, Statement, Step
-from .utils import POSITIONAL_PARAM_PREFIX, is_positional_key
+from .utils import MAX_SYMBOL_VALUE_LENGTH, POSITIONAL_PARAM_PREFIX, is_positional_key
 
 _SET_SYMBOL_PATTERN = re.compile(r"&&|&([A-Z0-9@#$]+)\.?")
 
 
-def _resolve_set_value(value: str, known_symbols: dict[str, str]) -> str:
+def _resolve_set_value(
+    value: str,
+    known_symbols: dict[str, str],
+    *,
+    symbol: str = "",
+    line_number: int = 0,
+    strict: bool = False,
+    warnings: list[str] | None = None,
+) -> str:
     """Resolve &SYMBOL references in a SET value using already-accumulated SET symbols.
 
     Mirrors the mainframe rule: SET values are evaluated left-to-right so a
@@ -36,15 +45,56 @@ def _resolve_set_value(value: str, known_symbols: dict[str, str]) -> str:
     itself holds a "&&NAME" temporary-dataset marker (e.g. ``SET
     MYTEMP=&&WORK``) before it ever reaches a DD statement. That collapse is
     explode_job()'s job (Tier 2), not this Tier-1 SET-value resolution.
+
+    A resolved value longer than :data:`~jclparser.utils.MAX_SYMBOL_VALUE_LENGTH`
+    is never built (#70): its length is computed first, and the value is
+    returned unresolved with a message on *warnings* -- or, when *strict*,
+    :class:`~jclparser.errors.JCLSyntaxError` is raised. *symbol* and
+    *line_number* only label that message.
     """
+    matches = list(_SET_SYMBOL_PATTERN.finditer(value))
+    if not matches:
+        return value
 
-    def _replacer(m: re.Match[str]) -> str:
+    def _replacement(m: re.Match[str]) -> str:
         if m.group(0) == "&&":
             return "&&"
-        sym = m.group(1).upper()
-        return known_symbols.get(sym, m.group(0))
+        return known_symbols.get(m.group(1).upper(), m.group(0))
 
-    return _SET_SYMBOL_PATTERN.sub(_replacer, value)
+    replacements = [_replacement(m) for m in matches]
+    length = len(value) + sum(
+        len(r) - len(m.group(0)) for m, r in zip(matches, replacements)
+    )
+    if length > MAX_SYMBOL_VALUE_LENGTH:
+        _report_set_overflow(symbol, length, line_number, strict, warnings)
+        return value
+    parts: list[str] = []
+    pos = 0
+    for m, r in zip(matches, replacements):
+        parts.append(value[pos : m.start()])
+        parts.append(r)
+        pos = m.end()
+    parts.append(value[pos:])
+    return "".join(parts)
+
+
+def _report_set_overflow(
+    symbol: str,
+    length: int,
+    line_number: int,
+    strict: bool,
+    warnings: list[str] | None,
+) -> None:
+    """Raise (strict) or warn that SET *symbol* would resolve to *length* chars."""
+    message = (
+        f"SET symbol &{symbol or '?'} would resolve to {length:,} characters, "
+        f"more than the {MAX_SYMBOL_VALUE_LENGTH:,}-character limit"
+    )
+    if strict:
+        raise JCLSyntaxError(message, line_number)
+    if warnings is not None:
+        prefix = f"Line {line_number}: " if line_number else ""
+        warnings.append(f"{prefix}{message}; value left unresolved")
 
 
 def _has_unresolved_symbol_ref(

{jcl_parser-2.0.0 → jcl_parser-2.0.2}/jclparser/_post_parse.py

@@ -24,7 +24,7 @@ from typing import TYPE_CHECKING, Any
 
 from ._model_factories import _has_unresolved_symbol_ref
 from .errors import JCLStructureError, JCLSyntaxError
-from .model import Job, Step, iter_execution_steps
+from .model import Job, OutputStatement, Step, iter_execution_steps
 from .utils import split_source_lines
 
 if TYPE_CHECKING:
@@ -48,64 +48,124 @@ def _extract_output_ref_names(value: Any) -> list[str]:
     Values that do not start with ``*.`` (e.g. a bare nodename, a qualified
     ``STEP.PROCSTEP.N`` form without the leading ``*.``, or ``None``) yield
     an empty list.  Callers rely on this to distinguish output-statement
-    references from other uses of the OUTPUT= parameter.
+    references from other uses of the OUTPUT= parameter.  The step
+    qualifiers are kept by :func:`_extract_output_refs`.
+    """
+    return [ref[-1] for ref in _extract_output_refs(value)]
+
+
+def _extract_output_refs(value: Any) -> list[tuple[str, ...]]:
+    """Return the ``*.`` OUTPUT references of a DD ``OUTPUT=`` value, qualified.
+
+    Each reference is the tuple of its uppercased segments::
+
+        OUTPUT=*.NAME                -> [("NAME",)]
+        OUTPUT=(*.STEP.NAME,*.N2)    -> [("STEP", "NAME"), ("N2",)]
+        OUTPUT=*.STEP.PROCSTEP.NAME  -> [("STEP", "PROCSTEP", "NAME")]
     """
-    names: list[str] = []
     items: list[str]
     if isinstance(value, list):
         items = [str(v) for v in value]
     elif isinstance(value, str):
         items = [value]
     else:
-        return names
+        return []
 
+    refs: list[tuple[str, ...]] = []
     for item in items:
         token = item.strip().strip("()")
         if not token.startswith("*."):
-            # Qualified form step.procstep.name uses ".name" — last segment after *
-            if ".*" in token:
-                # Not a back-reference either
-                continue
-            continue
-        ref = token[2:].strip()
-        if not ref:
             continue
-        # If qualified like STEP.PROCSTEP.NAME, take the final segment.
-        if "." in ref:
-            ref = ref.split(".")[-1]
-        names.append(ref.upper())
-    return names
+        segments = tuple(seg.strip().upper() for seg in token[2:].split("."))
+        if segments[-1]:
+            refs.append(segments)
+    return refs
+
+
+#: Key of an OUTPUT statement in :class:`_OutputScopes`:
+#: ``(procedure_name, step_name, name)``, uppercased; ``None`` for a level
+#: the statement is not coded in.
+_OutputKey = tuple[str | None, str | None, str]
+
+
+def _upper(name: str | None) -> str | None:
+    return name.upper() if name is not None else None
+
+
+class _OutputScopes:
+    """The job's OUTPUT statements, by the step (and PROC) they are coded in."""
+
+    def __init__(self, job: Job) -> None:
+        self.by_key: dict[_OutputKey, OutputStatement] = {}
+        for out in job.output_statements:
+            if out.name:
+                key = (
+                    _upper(out.procedure_name),
+                    _upper(out.step_name),
+                    out.name.upper(),
+                )
+                self.by_key[key] = out  # last wins if duplicated
+        self.instream_procs = {p.name.upper() for p in job.procedures}
+        self.step_procs = {
+            step.name.upper(): (step.procedure or "").upper()
+            for step in iter_execution_steps(job.steps)
+            if step.name
+        }
+
+    def checkable(self, ref: tuple[str, ...]) -> bool:
+        """False for ``*.step.procstep.name`` into a PROC that is not in-stream.
+
+        Its OUTPUT statements are not part of the job, so whether the
+        reference resolves cannot be told.
+        """
+        return len(ref) != 3 or self.step_procs.get(ref[0]) in self.instream_procs
+
+    def resolve(self, ref: tuple[str, ...], step_name: str) -> OutputStatement | None:
+        """The OUTPUT statement *ref* names from a DD in job step *step_name*.
+
+        ``*.name`` is the one in the DD's own step, else the job-level one;
+        ``*.step.name`` the one in job step *step*; ``*.step.procstep.name``
+        the one in step *procstep* of the in-stream PROC job step *step*
+        calls.
+        """
+        name = ref[-1]
+        if len(ref) == 1:
+            own = self.by_key.get((None, step_name.upper(), name))
+            return own if own is not None else self.by_key.get((None, None, name))
+        if len(ref) == 2:
+            return self.by_key.get((None, ref[0], name))
+        if len(ref) == 3:
+            return self.by_key.get((self.step_procs.get(ref[0]), ref[1], name))
+        return None
 
 
 def _resolve_output_refs(job: Job) -> None:
     """Populate ``DDStatement.output_refs`` for every DD that uses ``OUTPUT=*.X``.
 
-    Unresolved references (no matching :class:`OutputStatement`) are recorded
-    on ``job.unresolved_output_refs`` as ``(step_name, ref_name, line_number)``
-    tuples so :func:`jclparser.validators.validate_job_structure` can emit
-    warnings without re-scanning the parameter string.
+    A reference resolves by scope, not by name alone (#85): see
+    :meth:`_OutputScopes.resolve`. Unresolved references (no matching
+    :class:`OutputStatement`) are recorded on ``job.unresolved_output_refs``
+    as ``(step_name, ref, line_number)`` tuples, *ref* as coded after ``*.``
+    (``"NAME"``, ``"STEP.NAME"``), so
+    :func:`jclparser.validators.validate_job_structure` can emit warnings
+    without re-scanning the parameter string. A reference into a PROC that
+    is not in-stream cannot be checked and is neither.
     """
     if not job:
         return
-    # Index OUTPUT statements by uppercased name (last wins if duplicated).
-    output_by_name: dict[str, Any] = {
-        out.name.upper(): out for out in job.output_statements if out.name
-    }
-
-    from .model import iter_execution_steps
-
+    scopes = _OutputScopes(job)
     for step in iter_execution_steps(job.steps):
         for dd in step.dd_statements:
             value = dd.parameters.get("OUTPUT")
             if value is None:
                 continue
-            for ref in _extract_output_ref_names(value):
-                target = output_by_name.get(ref)
+            for ref in _extract_output_refs(value):
+                target = scopes.resolve(ref, step.name or "")
                 if target is not None:
                     dd.output_refs.append(target)
-                else:
+                elif scopes.checkable(ref):
                     job.unresolved_output_refs.append(
-                        (step.name or "", ref, dd.line_number)
+                        (step.name or "", ".".join(ref), dd.line_number)
                     )
 
 
@@ -186,7 +246,7 @@ def enforce_strict_dd_structure(content: str) -> None:
                 )
 
 
-def resolve_set_symbols(job: Job) -> None:
+def resolve_set_symbols(job: Job, strict: bool = False) -> None:
     """Substitute fully-resolved SET symbols into DD and EXEC-step parameters.
 
     SET statements may appear before or after the DD statements that reference
@@ -214,11 +274,17 @@ def resolve_set_symbols(job: Job) -> None:
     pass.  It also covers EXEC step parameters (e.g. ``PARM=&SYM``), not just
     DD dataset names/dispositions, so a job-level SET symbol resolves the same
     way regardless of which kind of statement references it.
+
+    A SET value whose expansion would exceed ``utils.MAX_SYMBOL_VALUE_LENGTH``
+    characters is left unresolved with one warning on ``job.warnings`` (#70);
+    a statement referencing it keeps the reference as written (again with a
+    warning). With *strict*, :class:`~jclparser.errors.JCLSyntaxError` is
+    raised instead.
     """
     from .explosion import substitute_dd_statement
     from .system_symbols import is_system_symbol_name
 
-    _set_scope = _scope_for_table(job.set_statements)
+    _set_scope = _scope_for_table(job.set_statements, job.warnings, strict)
     # A step read before a SET redefined a symbol sees the value in effect at
     # that point (Step.set_symbols); symbols it has no snapshot for (forward
     # references) still fall back to the job's final table.
@@ -230,7 +296,7 @@ def resolve_set_symbols(job: Job) -> None:
     for _owner, _dd in _dds_with_owners(_flat_steps):
         substitute_dd_statement(
             _dd,
-            _scope_for_step(_owner, job, _set_scope, _step_scopes),
+            _scope_for_step(_owner, job, _set_scope, _step_scopes, strict),
             strict=False,
             warnings=job.warnings,
             collapse_double_amp=False,
@@ -238,14 +304,18 @@ def resolve_set_symbols(job: Job) -> None:
         )
 
     for _step in _flat_steps:
-        _step_scope = _scope_for_step(_step, job, _set_scope, _step_scopes)
+        _step_scope = _scope_for_step(_step, job, _set_scope, _step_scopes, strict)
         _substitute_step_parameters(_step, _step_scope, job.warnings)
         _substitute_step_names(_step, _step_scope)
 
 
-def _preresolve_set_table(table: dict[str, str]) -> dict[str, str]:
-    """Return a copy of SET *table* with symbol references between values expanded."""
-    from .explosion import SymbolScope, substitute_symbols
+def _preresolve_set_table(table: dict[str, str]) -> tuple[dict[str, str], list[str]]:
+    """Return a copy of SET *table* with symbol references between values expanded.
+
+    Also returns the names of the symbols whose expansion would exceed
+    ``utils.MAX_SYMBOL_VALUE_LENGTH``; those keep their unexpanded value.
+    """
+    from .explosion import SymbolScope, _substitute_symbols_bounded, _SymbolOverflow
 
     # Pre-resolve the symbol table so every value is fully expanded before
     # we apply it to DD dataset names.  On each pass we substitute symbols
@@ -253,36 +323,67 @@ def _preresolve_set_table(table: dict[str, str]) -> dict[str, str]:
     # (excluding the symbol itself prevents direct self-reference loops).
     # We repeat until no value changes or we reach the pass limit.
     _raw: dict[str, str] = dict(table)
+    _overflowed: list[str] = []
     for _pass in range(10):
         _changed = False
         for _name, _val in list(_raw.items()):
-            if "&" not in _val:
+            if "&" not in _val or _name in _overflowed:
                 continue
             # Build a temporary scope that excludes this symbol's own name
             # so "&A." inside SET A's value does not expand to itself.
             _scope_for_val = SymbolScope(
                 set_symbols={k: v for k, v in _raw.items() if k != _name}
             )
-            _new_val = substitute_symbols(
-                _val,
-                _scope_for_val,
-                allow_undefined=True,
-                collapse_double_amp=False,
-            )
+            try:
+                _new_val = _substitute_symbols_bounded(
+                    _val,
+                    _scope_for_val,
+                    allow_undefined=True,
+                    collapse_double_amp=False,
+                )
+            except _SymbolOverflow:
+                # Values only grow from pass to pass: never retry it.
+                _overflowed.append(_name)
+                continue
             if _new_val != _val:
                 _raw[_name] = _new_val
                 _changed = True
         if not _changed:
             break  # table has stabilised – no need for more passes
-    return _raw
+    return _raw, _overflowed
 
 
-def _scope_for_table(table: dict[str, str]) -> SymbolScope:
-    """Build the substitution scope for SET symbol *table* (see resolve_set_symbols)."""
+def _report_table_overflow(
+    overflowed: list[str], warnings: list[str], strict: bool
+) -> None:
+    """Raise (strict) or warn once that the *overflowed* SET symbols stay unresolved."""
+    from .utils import MAX_SYMBOL_VALUE_LENGTH
+
+    names = ", ".join(f"&{n}" for n in overflowed)
+    message = (
+        f"SET symbol(s) {names} expand to more than "
+        f"{MAX_SYMBOL_VALUE_LENGTH:,} characters"
+    )
+    if strict:
+        raise JCLSyntaxError(message)
+    message += "; left unresolved"
+    if message not in warnings:
+        warnings.append(message)
+
+
+def _scope_for_table(
+    table: dict[str, str], warnings: list[str], strict: bool = False
+) -> SymbolScope:
+    """Build the substitution scope for SET symbol *table* (see resolve_set_symbols).
+
+    Overflow of a SET value is reported on *warnings* (or raised, *strict*).
+    """
     from .explosion import SymbolScope
     from .system_symbols import is_system_symbol_name
 
-    _raw = _preresolve_set_table(table)
+    _raw, _overflowed = _preresolve_set_table(table)
+    if _overflowed:
+        _report_table_overflow(_overflowed, warnings, strict)
 
     # Symbols whose values still contain a genuinely unresolved
     # &-reference after all passes are excluded from the final scope.
@@ -295,10 +396,15 @@ def _scope_for_table(table: dict[str, str]) -> SymbolScope:
     # ``DSN=&SYSUID..WORK`` before that pass runs (keep_undefined below). A value that legitimately contains "&&" (e.g.
     # SET MYTEMP=&&WORK) is NOT excluded -- it has nothing left to
     # resolve, it just happens to contain an escaped literal ampersand.
+    #
+    # An overflowed symbol keeps its unexpanded value in the scope, so a
+    # statement referencing it overflows the substitution budget in turn and
+    # keeps the reference as written instead of having it blanked (#70).
     _resolved_symbols = {
         k: v
         for k, v in _raw.items()
-        if not _has_unresolved_symbol_ref(v, ignore=is_system_symbol_name)
+        if k in _overflowed
+        or not _has_unresolved_symbol_ref(v, ignore=is_system_symbol_name)
     }
     return SymbolScope(set_symbols=_resolved_symbols)
 
@@ -308,6 +414,7 @@ def _scope_for_step(
     job: Job,
     set_scope: SymbolScope,
     step_scopes: dict[int, SymbolScope],
+    strict: bool = False,
 ) -> SymbolScope:
     """Return the SET scope in effect for *step*, memoised in *step_scopes*.
 
@@ -318,7 +425,7 @@ def _scope_for_step(
         return set_scope
     if id(step) not in step_scopes:
         step_scopes[id(step)] = _scope_for_table(
-            {**job.set_statements, **step.set_symbols}
+            {**job.set_statements, **step.set_symbols}, job.warnings, strict
         )
     return step_scopes[id(step)]
 

{jcl_parser-2.0.0 → jcl_parser-2.0.2}/jclparser/_source_scanner.py

@@ -31,7 +31,7 @@ from .errors import JCLSyntaxError
 from .utils import (
     instream_delimiter,
     is_continued_card_image,
-    normalize_jcl_line,
+    normalize_jcl_lines,
     split_source_lines,
 )
 
@@ -60,7 +60,7 @@ def _merge_source_lines(content: str) -> ScannedSource:
     or garbled records).
     """
     raw_lines = split_source_lines(content)
-    lines = [normalize_jcl_line(line) for line in raw_lines]
+    lines = normalize_jcl_lines(raw_lines)
 
     classifier = _RecordClassifier(lines)
     jcl_indices = classifier.run()
@@ -116,7 +116,10 @@ def merge_continuations(
         card_images={
             n
             for n, orig in enumerate(indices)
-            if is_continued_card_image(raw_lines[orig])
+            if is_continued_card_image(
+                raw_lines[orig],
+                raw_lines[orig + 1] if orig + 1 < len(raw_lines) else None,
+            )
         },
     )
 

{jcl_parser-2.0.0 → jcl_parser-2.0.2}/jclparser/_statement_parser.py

@@ -173,17 +173,36 @@ def _resumes_operands(text: str) -> bool:
     return "=" in token.split(",")[0]
 
 
-def _find_comment_start(operands: str) -> int | None:
+def _closes_parens(text: str, depth: int) -> bool:
+    """Return True if *text*, read at paren *depth*, brings the depth to 0."""
+    in_quotes = False
+    for char in text:
+        if char == "'":
+            in_quotes = not in_quotes
+        elif not in_quotes:
+            if char == "(":
+                depth += 1
+            elif char == ")":
+                depth -= 1
+                if depth <= 0:
+                    return True
+    return False
+
+
+def _find_comment_start(operands: str, depth: int = 0) -> int | None:
     """Index of the comment field inside *operands*, or ``None`` if there is none.
 
     The operand field ends at the first blank that is outside quotes and
     outside parentheses; everything after it is the comment field (z/OS JCL
-    Reference, "Comment field").
+    Reference, "Comment field"). Inside a parenthesised list, a blank that
+    follows a subparameter's comma also starts a comment when the rest of
+    the record neither resumes operands nor closes the list: the list goes
+    on in the next record. *depth* is the paren depth the record starts at
+    (non-zero for a record continuing an open list).
     """
     if " " not in operands and "\t" not in operands:
         # No blank at all: the operand field runs to the end of the record.
         return None
-    depth = 0
     in_quotes = False
     i = 0
     n = len(operands)
@@ -207,6 +226,16 @@ def _find_comment_start(operands: str) -> int | None:
                     i = n - len(rest)
                     continue
                 return i
+            elif (
+                char.isspace()
+                and operands[:i].endswith(",")
+                and not _resumes_operands(operands[i:].lstrip())
+                and not _closes_parens(operands[i:], depth)
+            ):
+                # A parenthesised list interrupted after a subparameter's
+                # comma may carry a comment (z/OS JCL Reference, "Continuing
+                # the operand field"); the list resumes on the next record.
+                return i
         i += 1
     return None
 
@@ -240,7 +269,9 @@ def _find_then_end(operands: str) -> int | None:
     return None
 
 
-def split_comment_field(line: str, group_operation: str = "") -> tuple[str, str]:
+def split_comment_field(
+    line: str, group_operation: str = "", paren_depth: int = 0
+) -> tuple[str, str]:
     """Split a JCL statement record into ``(statement, comment)``.
 
     In JCL a statement's operand field ends at the first blank outside quotes
@@ -270,7 +301,7 @@ def split_comment_field(line: str, group_operation: str = "") -> tuple[str, str]
         if cut is None:
             return line, ""
         return (line[:start] + operands[:cut]).rstrip(), operands[cut:].strip()
-    cut = _find_comment_start(operands)
+    cut = _find_comment_start(operands, paren_depth)
     if cut is None:
         return line, ""
     return (line[:start] + operands[:cut]).rstrip(), operands[cut:].strip()