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

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: jcl-parser
-Version: 2.0.2
+Version: 2.1.0
 Summary: Parse IBM JCL (Job Control Language) scripts into Python objects
-Author-email: JCL Parser Team <team@jclparser.dev>
+Author-email: Samuel Dion <sam94dion@gmail.com>
 License: AGPL-3.0-or-later
 Project-URL: Homepage, https://github.com/landparty/jcl-parser
 Project-URL: Repository, https://github.com/landparty/jcl-parser
-Project-URL: Documentation, https://github.com/landparty/jcl-parser/tree/main/docs
+Project-URL: Documentation, https://github.com/landparty/jcl-parser/tree/main/.okf
 Project-URL: Bug Reports, https://github.com/landparty/jcl-parser/issues
 Keywords: jcl,mainframe,parser,ibm,job-control-language
 Classifier: Development Status :: 5 - Production/Stable

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: jcl-parser
-Version: 2.0.2
+Version: 2.1.0
 Summary: Parse IBM JCL (Job Control Language) scripts into Python objects
-Author-email: JCL Parser Team <team@jclparser.dev>
+Author-email: Samuel Dion <sam94dion@gmail.com>
 License: AGPL-3.0-or-later
 Project-URL: Homepage, https://github.com/landparty/jcl-parser
 Project-URL: Repository, https://github.com/landparty/jcl-parser
-Project-URL: Documentation, https://github.com/landparty/jcl-parser/tree/main/docs
+Project-URL: Documentation, https://github.com/landparty/jcl-parser/tree/main/.okf
 Project-URL: Bug Reports, https://github.com/landparty/jcl-parser/issues
 Keywords: jcl,mainframe,parser,ibm,job-control-language
 Classifier: Development Status :: 5 - Production/Stable

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

@@ -9,6 +9,7 @@ jcl_parser.egg-info/requires.txt
 jcl_parser.egg-info/top_level.txt
 jclparser/__init__.py
 jclparser/__main__.py
+jclparser/_include_origins.py
 jclparser/_job_builder.py
 jclparser/_model_factories.py
 jclparser/_post_parse.py

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

@@ -20,7 +20,7 @@ application, for example::
 import logging as _logging
 
 # Package metadata
-__version__ = "2.0.2"  # x-release-please-version
+__version__ = "2.1.0"  # x-release-please-version
 __author__ = "JCL Parser Team"
 __description__ = "Parse IBM JCL scripts into Python objects"
 
@@ -66,7 +66,9 @@ from .include_loader import (
     DictMemberLoader,
     IncludeMemberLoader,
     JCLLIBMemberLoader,
+    LineOrigin,
     resolve_includes,
+    resolve_includes_with_origins,
 )
 from .jcl_file_type import (
     FileType,
@@ -100,7 +102,16 @@ from .lint import (
     to_sarif as lint_to_sarif,
 )
 from .metrics import JobMetrics, compute_metrics
-from .model import DDStatement, Job, OutputStatement, Parameter, Statement, Step
+from .model import (
+    ConditionalBlock,
+    DDStatement,
+    Job,
+    OutputStatement,
+    Parameter,
+    Statement,
+    Step,
+    iter_execution_steps,
+)
 from .parser import parse_jcl, parse_statement, validate_jcl
 from .plugins import (
     ParserConfig,
@@ -172,6 +183,8 @@ __all__ = [  # noqa: RUF022 — grouped by API tier, not alphabetically
     "Parameter",
     "Statement",
     "OutputStatement",
+    "ConditionalBlock",
+    "iter_execution_steps",
     "JCLParseError",
     "JCLSyntaxError",
     "JCLValidationError",
@@ -230,7 +243,9 @@ __all__ = [  # noqa: RUF022 — grouped by API tier, not alphabetically
     "IncludeMemberLoader",
     "DictMemberLoader",
     "JCLLIBMemberLoader",
+    "LineOrigin",
     "resolve_includes",
+    "resolve_includes_with_origins",
     # ── Tier 2: Dataset lifecycle analysis ───────────────────────────────────
     "DatasetEvent",
     "analyze_dataset_lifecycle",

jcl_parser-2.1.0/jclparser/_include_origins.py

@@ -0,0 +1,126 @@
+"""Report INCLUDE-expanded line numbers against the main source (issue #118).
+
+``// INCLUDE MEMBER=`` statements are expanded before the source is scanned,
+so every line number the parser computes counts the inlined member lines.
+:class:`IncludeLineMap` translates such a number back: a main-source line to
+its own line, a member line to the line of the ``// INCLUDE`` statement in
+the main source (the outermost one, for a nested INCLUDE).  Messages about a
+member line also name the member and the line within it::
+
+    Line 2 (INCLUDE member COMMON, line 3): EXEC statement missing ...
+
+The parse runs on the expanded text unchanged; :func:`_parse_jcl_core
+<jclparser.parser._parse_jcl_core>` applies the translation once, at the end
+(:meth:`IncludeLineMap.relabel_job`) or to the exception that ends the parse
+(:meth:`IncludeLineMap.relabel_error`).
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import re
+from collections.abc import Iterable
+from typing import Any
+
+from .errors import JCLParseError
+from .include_loader import LineOrigin
+from .model import Job, Procedure
+
+_LEADING_LINE = re.compile(r"^Line (\d+)")
+_INNER_LINE = re.compile(r"\bon line (\d+)\b")
+
+
+class IncludeLineMap:
+    """Line number translation for one INCLUDE-expanded source."""
+
+    def __init__(self, origins: list[LineOrigin]) -> None:
+        self._origins = origins
+
+    def origin(self, line_number: int) -> LineOrigin | None:
+        """Where expanded line *line_number* came from (None if unknown)."""
+        if 1 <= line_number <= len(self._origins):
+            return self._origins[line_number - 1]
+        return None
+
+    def translate(self, line_number: int) -> int:
+        """The main-source line of expanded line *line_number*."""
+        origin = self.origin(line_number)
+        return origin.line if origin is not None else line_number
+
+    def note(self, line_number: int) -> str:
+        """``"INCLUDE member M, line k"`` for a member line, else ``""``."""
+        origin = self.origin(line_number)
+        if origin is None or origin.member is None:
+            return ""
+        return f"INCLUDE member {origin.member}, line {origin.member_line}"
+
+    def label(self, line_number: int) -> str:
+        """``"Line N"``, plus the member note for a member line."""
+        note = self.note(line_number)
+        main_line = self.translate(line_number)
+        return f"Line {main_line} ({note})" if note else f"Line {main_line}"
+
+    def relabel_text(self, text: str) -> str:
+        """Translate the ``Line N`` prefix (and ``on line N``) of a message."""
+        text = _LEADING_LINE.sub(lambda m: self.label(int(m.group(1))), text, 1)
+        return _INNER_LINE.sub(
+            lambda m: f"on line {self.translate(int(m.group(1)))}", text
+        )
+
+    def relabel_error(self, exc: JCLParseError) -> None:
+        """Translate the line number of the exception that ended the parse."""
+        if exc.line_number <= 0:
+            return
+        exc.include_note = self.note(exc.line_number)
+        exc.line_number = self.translate(exc.line_number)
+        exc.args = (exc._format_message(),)
+
+    def relabel_job(self, job: Job, own_procedures: Iterable[Procedure]) -> None:
+        """Translate every line number on *job* and in its warnings.
+
+        Only the procedures in *own_procedures* -- the in-stream ones, read
+        from this source -- are relabelled: an external or built-in PROC
+        carries line numbers of its own library member.
+        """
+        own = {id(proc) for proc in own_procedures}
+        skip = {id(p) for p in job.procedures if id(p) not in own}
+        self._relabel_object(job, skip)
+        job.warnings[:] = [self.relabel_text(w) for w in job.warnings]
+        job.unresolved_output_refs[:] = [
+            (step_name, ref, self.translate(line))
+            for step_name, ref, line in job.unresolved_output_refs
+        ]
+
+    def _relabel_object(self, obj: Any, seen: set[int]) -> None:
+        """Translate ``line_number`` on *obj* and every model object under it."""
+        if id(obj) in seen:
+            return
+        seen.add(id(obj))
+        if isinstance(obj, (list, tuple)):
+            for item in obj:
+                self._relabel_object(item, seen)
+        elif isinstance(obj, dict):
+            for item in obj.values():
+                self._relabel_object(item, seen)
+        elif _is_model_object(obj):
+            self._relabel_fields(obj, seen)
+
+    def _relabel_fields(self, obj: Any, seen: set[int]) -> None:
+        line_number = getattr(obj, "line_number", None)
+        if isinstance(line_number, int) and line_number > 0:
+            try:
+                obj.line_number = self.translate(line_number)
+            except dataclasses.FrozenInstanceError:
+                pass
+        for field in dataclasses.fields(obj):
+            if not field.name.startswith("_") and field.name != "line_number":
+                self._relabel_object(getattr(obj, field.name), seen)
+
+
+def _is_model_object(obj: Any) -> bool:
+    """A jclparser dataclass instance (not a class, not a foreign type)."""
+    return (
+        dataclasses.is_dataclass(obj)
+        and not isinstance(obj, type)
+        and type(obj).__module__.startswith("jclparser")
+    )

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

@@ -34,6 +34,7 @@ from ._model_factories import (
     _create_step_from_statement,
     _exec_has_program_spec,
     _has_unresolved_symbol_ref,
+    _resolve_jcllib_library,
     _resolve_set_value,
 )
 from ._post_parse import (
@@ -59,6 +60,8 @@ from .utils import (
     instream_delimiter,
     is_positional_key,
     jcl_value_text,
+    jes_xmit_delimiter,
+    xmit_delimiter,
 )
 
 logger = logging.getLogger(__name__)
@@ -103,8 +106,8 @@ class JobBuilder:
 
     # Statement type -> name of its ``_on_<type>`` handler.  Every type in
     # ``_STATEMENT_TYPES`` must appear here, even when its handler is a
-    # deliberate no-op (NULL, ENDCNTL): an unlisted type is dropped
-    # without a trace.
+    # deliberate no-op (NULL, ENDCNTL).  Any other type -- a custom type
+    # returned by a StatementPlugin -- is kept in ``Job.custom_statements``.
     _HANDLERS: ClassVar[dict[str, str]] = {
         "JOB": "_on_job",
         "EXEC": "_on_exec",
@@ -122,10 +125,12 @@ class JobBuilder:
         "JES": "_on_jes",
         "OUTPUT": "_on_output",
         "NULL": "_on_null",
-        # No richer model representation for COMMAND / SCHEDULE / CNTL.
+        # No richer model representation for COMMAND / SCHEDULE / CNTL /
+        # NOTIFY (z/OS 2.3).
         "COMMAND": "_on_control",
         "SCHEDULE": "_on_control",
         "CNTL": "_on_control",
+        "NOTIFY": "_on_control",
         "ENDCNTL": "_on_endcntl",
         "UNKNOWN": "_on_unknown",
         "XMIT": "_on_xmit",
@@ -151,8 +156,15 @@ class JobBuilder:
         self.pending_procedures: list[Procedure] = []
         self.current_delimiter = "/*"
         self.current_terminates_on_slash = False
-        #: Track DDs that appear before first EXEC
+        #: Job-level DDs that appear before the first job-level EXEC (e.g.
+        #: ``SYSCHK``/``JOBCAT``); attached to that step, never to a step of an
+        #: in-stream PROC defined in between (#103).
         self.orphaned_dds: list[DDStatement] = []
+        #: DDs inside a PROC/PEND body before the procedure's first EXEC.
+        self.proc_orphaned_dds: list[DDStatement] = []
+        #: ``len(conditional_stack)`` when the open PROC began: IF blocks at
+        #: or below it belong to the enclosing job, not to the procedure.
+        self.proc_cond_depth = 0
         #: True while accumulating JOBLIB concatenation lines
         self.in_joblib_concat = False
         #: Qualified name (``PROCSTEP.DDNAME``) of the override DD the current
@@ -174,6 +186,10 @@ class JobBuilder:
         #: only if some SET symbol is redefined after it was first set.
         self.job_level_steps: list[Step] = []
         self.set_redefined = False
+        #: Steps of in-stream / cataloged procedures with the procedure they
+        #: belong to; finish() prunes their ``set_symbols`` snapshot the same
+        #: way (against the procedure's own final SET table).
+        self.procedure_steps: list[tuple[Procedure, Step]] = []
         self.pending_exported: set[str] = set()
         self.pending_jcllib: list[str] = []
         self.pending_includes: list[str] = []
@@ -181,6 +197,9 @@ class JobBuilder:
         self.pending_conditionals: list[ConditionalBlock] = []
         self.pending_steps: list[Step | ConditionalBlock] = []
         self.pending_control: list[Statement] = []
+        #: Statements of a type the builder has no handler for (e.g. a custom
+        #: type returned by a StatementPlugin) seen before the JOB statement.
+        self.pending_custom: list[Statement] = []
         #: The open ``CNTL`` block, whose program control records are collected
         #: verbatim until its ``ENDCNTL``.
         self.current_cntl: Statement | None = None
@@ -280,13 +299,17 @@ class JobBuilder:
     # ------------------------------------------------------------------ #
 
     def handle_statement(self, stmt: Statement, line_num: int) -> None:
-        """Record statement warnings, then dispatch to the type handler."""
+        """Record statement warnings, then dispatch to the type handler.
+
+        A statement whose type has no handler in :attr:`_HANDLERS` (e.g. a
+        custom type returned by a :class:`~jclparser.plugins.StatementPlugin`)
+        is kept verbatim in :attr:`Job.custom_statements` (#130).
+        """
         if stmt.warnings:
             self._warnings_sink().extend(stmt.warnings)
 
-        handler_name = self._HANDLERS.get(stmt.type)
-        if handler_name is not None:
-            getattr(self, handler_name)(stmt, line_num)
+        handler_name = self._HANDLERS.get(stmt.type, "_on_custom")
+        getattr(self, handler_name)(stmt, line_num)
 
     # ------------------------------------------------------------------ #
     # Per-statement-type handlers
@@ -315,27 +338,27 @@ class JobBuilder:
                 **self.job.set_statements,
             }
             self.job_level_steps.append(self.current_step)
+        elif self.current_procedure is not None:
+            # A SET inside the procedure is in effect from where it is coded,
+            # so this step sees the procedure's SET values as they stand now.
+            self.current_step.set_symbols = dict(self.current_procedure.set_statements)
+            self.procedure_steps.append((self.current_procedure, self.current_step))
         self.in_joblib_concat = False  # JOBLIB concatenation ends at first EXEC
         self.concat_override_key = None
 
-        # Attach any orphaned DDs to this first step
-        if self.orphaned_dds:
-            for dd in self.orphaned_dds:
-                self.current_step.add_dd(dd)
-            self.orphaned_dds = []
-
-        # Add step to procedure if we're inside PROC/PEND, otherwise to job
-        if self.conditional_stack:
-            active_cond, active_branch = self.conditional_stack[-1]
-            if active_branch == "THEN":
-                active_cond.add_then_step(self.current_step)
-            else:
-                active_cond.add_else_step(self.current_step)
-        elif self.current_procedure is not None:
-            self.current_procedure.steps.append(self.current_step)
+        # Attach DDs seen before the first EXEC of this scope to this step.
+        # Job-level DDs (SYSCHK, JOBCAT, ...) wait for the first job-level
+        # EXEC: a step inside an in-stream PROC definition must never pick
+        # them up, or every expansion of the PROC would copy them (#103).
+        if self.current_procedure is not None:
+            pending_dds, self.proc_orphaned_dds = self.proc_orphaned_dds, []
         else:
-            assert self.job is not None
-            self.job.add_step(self.current_step)
+            pending_dds, self.orphaned_dds = self.orphaned_dds, []
+        for dd in pending_dds:
+            self.current_step.add_dd(dd)
+
+        # Add step to the open IF branch, the PROC being defined, or the job
+        self._attach(self.current_step)
 
     def _on_dd(self, stmt: Statement, line_num: int) -> None:
         # Create the DD statement
@@ -351,9 +374,12 @@ class JobBuilder:
             elif not stmt.name and self.in_joblib_concat and self.job is not None:
                 # Empty-name DD concatenating onto the JOBLIB group
                 self.job.joblib_dds.append(current_dd)
+            elif self.current_procedure is not None:
+                # DD in a PROC body before its first EXEC
+                self.proc_orphaned_dds.append(current_dd)
             else:
                 self.in_joblib_concat = False
-                # Store as orphaned DD to be attached to next step
+                # Job-level DD: attached to the next job-level step
                 self.orphaned_dds.append(current_dd)
         elif stmt.name and "." in stmt.name:
             # This is a DD override for a procedure step
@@ -419,14 +445,43 @@ class JobBuilder:
             self.job.add_procedure(self.current_procedure)
         else:
             self.pending_procedures.append(self.current_procedure)
+        # IF blocks already open belong to the job, not to this procedure.
+        self.proc_cond_depth = len(self.conditional_stack)
         # Reset current_step since we're now inside procedure
         self.current_step = None
+        self.in_joblib_concat = False
+        self.proc_orphaned_dds = []
 
     def _on_pend(self, stmt: Statement, line_num: int) -> None:
-        # End of procedure definition - stop tracking
+        # End of procedure definition - stop tracking.  PEND closes the PROC
+        # scope: an IF opened in the body and never closed by ENDIF ends here
+        # (it is already attached to the procedure), so later job steps are
+        # not read into it (#102).
+        procedure = self.current_procedure
+        if procedure is not None:
+            while len(self.conditional_stack) > self.proc_cond_depth:
+                cond, _branch = self.conditional_stack.pop()
+                self._warnings_sink().append(
+                    f"Line {cond.line_number}: IF block in PROC {procedure.name} "
+                    f"has no matching ENDIF; closed at PEND (line {line_num})"
+                )
+            self._warn_proc_orphaned_dds(procedure, line_num)
+        self.proc_orphaned_dds = []
+        self.proc_cond_depth = 0
         self.current_procedure = None
         self.current_step = None
 
+    def _warn_proc_orphaned_dds(self, procedure: Procedure, line_num: int) -> None:
+        """Report DDs of a PROC body that had no EXEC step to attach to."""
+        if self.proc_orphaned_dds:
+            dd_names = ", ".join(
+                dd.name or "(unnamed)" for dd in self.proc_orphaned_dds
+            )
+            self._warnings_sink().append(
+                f"Line {line_num}: PROC {procedure.name} has DD statement(s) "
+                f"but no EXEC step to attach them to; discarded: {dd_names}"
+            )
+
     def _on_set(self, stmt: Statement, line_num: int) -> None:
         # SET symbol=value statement.  A SET before the JOB statement (or in a
         # JOB-less member) is buffered rather than dropped; finish() flushes it.
@@ -498,11 +553,26 @@ class JobBuilder:
         order_value = stmt.parameters["ORDER"]
         sink = self.job.jcllib_order if self.job else self.pending_jcllib
         # ORDER parameter might already be parsed as a list
+        libs: list[str] = []
         if isinstance(order_value, list):
-            sink.extend(order_value)
+            libs = [str(lib) for lib in order_value]
         elif isinstance(order_value, str):
-            libs = order_value.strip("()").split(",")
-            sink.extend([lib.strip() for lib in libs])
+            libs = [lib.strip() for lib in order_value.strip("()").split(",")]
+        # Only the SETs coded before this statement are in effect here.
+        symbols = (
+            {**self.pending_sets, **self.job.set_statements}
+            if self.job
+            else self.pending_sets
+        )
+        for lib in libs:
+            resolved = _resolve_jcllib_library(lib, symbols)
+            if resolved is None:
+                self._warnings_sink().append(
+                    f"Line {stmt.line_number}: JCLLIB ORDER library {lib} "
+                    "contains an unresolved symbol; kept as written"
+                )
+                resolved = lib
+            sink.append(resolved)
 
     def _on_include(self, stmt: Statement, line_num: int) -> None:
         # INCLUDE MEMBER=name
@@ -545,20 +615,32 @@ class JobBuilder:
             condition = condition[:-5]
         return condition
 
-    def _attach_conditional(self, conditional: ConditionalBlock) -> None:
-        """Place a new IF block in the enclosing branch, PROC, job or buffer."""
-        if self.conditional_stack:
-            active_cond, active_branch = self.conditional_stack[-1]
+    def _innermost_if(self) -> tuple[ConditionalBlock, str] | None:
+        """The innermost IF block open in the current scope, or None.
+
+        Inside a PROC/PEND body only IF blocks opened in that body count; an
+        IF the job opened before the PROC statement stays the job's (#102).
+        """
+        floor = self.proc_cond_depth if self.current_procedure is not None else 0
+        if len(self.conditional_stack) > floor:
+            return self.conditional_stack[-1]
+        return None
+
+    def _attach(self, item: Step | ConditionalBlock) -> None:
+        """Place a step or IF block in the open branch, PROC, job or buffer."""
+        open_if = self._innermost_if()
+        if open_if is not None:
+            active_cond, active_branch = open_if
             if active_branch == "THEN":
-                active_cond.add_then_step(conditional)
+                active_cond.add_then_step(item)
             else:
-                active_cond.add_else_step(conditional)
+                active_cond.add_else_step(item)
         elif self.current_procedure is not None:
-            self.current_procedure.steps.append(conditional)
+            self.current_procedure.steps.append(item)
         elif self.job is not None:
-            self.job.steps.append(conditional)
+            self.job.steps.append(item)
         else:
-            self.pending_steps.append(conditional)
+            self.pending_steps.append(item)
 
     def _open_if(self, stmt: Statement) -> None:
         """Handle ``IF``: record a new :class:`ConditionalBlock` and enter it."""
@@ -572,14 +654,14 @@ class JobBuilder:
             self.job.add_conditional(conditional)
         else:
             self.pending_conditionals.append(conditional)
-        self._attach_conditional(conditional)
+        self._attach(conditional)
         self.conditional_stack.append((conditional, "THEN"))
 
     def _switch_branch(self, branch: str, line_num: int) -> None:
         """Handle ``THEN`` / ``ELSE``: make *branch* the open IF's active one."""
-        if self.conditional_stack:
-            active_cond, _ = self.conditional_stack.pop()
-            self.conditional_stack.append((active_cond, branch))
+        open_if = self._innermost_if()
+        if open_if is not None:
+            self.conditional_stack[-1] = (open_if[0], branch)
         else:
             self._warnings_sink().append(
                 f"Line {line_num}: {branch} with no matching IF; ignored"
@@ -587,7 +669,7 @@ class JobBuilder:
 
     def _close_if(self, line_num: int) -> None:
         """Handle ``ENDIF``: leave the innermost open IF block."""
-        if self.conditional_stack:
+        if self._innermost_if() is not None:
             self.conditional_stack.pop()
         else:
             self._warnings_sink().append(
@@ -601,6 +683,13 @@ class JobBuilder:
         from .jes_statements import parse_jes_control
 
         typed = parse_jes_control(stmt.name, raw_params, stmt.line_number)
+        if stmt.name.upper() == "XMIT":
+            # The records that follow are a job stream for another node,
+            # not JCL of this job; they end at /* or DLM= (issue #117).
+            self.current_dd = None
+            self._start_transmitted_data(
+                jes_xmit_delimiter(raw_params), stmt.line_number
+            )
         if self.dialect == "jes3" and stmt.name.upper() not in _JES3_SLASH_STAR:
             # JES3 does not process JES2 control statements: keep the text,
             # but do not interpret it, and say so.
@@ -640,7 +729,7 @@ class JobBuilder:
         pass
 
     def _on_control(self, stmt: Statement, line_num: int) -> None:
-        """Record a COMMAND / SCHEDULE / CNTL statement verbatim."""
+        """Record a COMMAND / SCHEDULE / CNTL / NOTIFY statement verbatim."""
         # No richer model representation, but they are real statements —
         # record them verbatim rather than discarding them.
         if stmt.type == "CNTL":
@@ -659,6 +748,22 @@ class JobBuilder:
         if self.current_cntl is not None:
             self.current_cntl.parameters["_records"].append(line)
 
+    def _on_custom(self, stmt: Statement, line_num: int) -> None:
+        """Keep a statement of a type the builder has no handler for.
+
+        Such statements come from a :class:`~jclparser.plugins.StatementPlugin`
+        returning a custom ``Statement.type``; they used to be dropped
+        silently (#130).
+        """
+        logger.debug(
+            "no handler for statement type %r at line %d; kept in "
+            "Job.custom_statements",
+            stmt.type,
+            line_num,
+        )
+        sink = self.job.custom_statements if self.job else self.pending_custom
+        sink.append(stmt)
+
     def _on_unknown(self, stmt: Statement, line_num: int) -> None:
         # Unknown statement type - log but continue processing
         statement_type_name = stmt.parameters.get("_statement_type", "")
@@ -682,8 +787,6 @@ class JobBuilder:
                 line_number=stmt.line_number,
             )
             self.current_step.add_dd(self.current_dd)
-            self.in_inline_data = True
-            self.inline_data_lines = []
         else:
             # Job-level XMIT has no step to attach a DD to, but the
             # transmitted data block that follows must still be
@@ -693,12 +796,29 @@ class JobBuilder:
             # it; clear current_dd so the inline-data-end handler
             # doesn't misattach it to an unrelated earlier DD.
             self.current_dd = None
-            self.in_inline_data = True
-            self.inline_data_lines = []
             self._warnings_sink().append(
                 f"Line {stmt.line_number}: job-level XMIT has no step to attach "
                 f"its data to; the transmitted records were discarded"
             )
+        self._start_transmitted_data(xmit_delimiter(stmt.parameters), stmt.line_number)
+
+    def _start_transmitted_data(self, delimiter: Any, line_num: int) -> None:
+        """Open the data block of an XMIT / ``/*XMIT`` statement.
+
+        The transmitted records are a job stream for another node, so a
+        ``//`` record never ends them: only ``/*`` or the ``DLM=`` delimiter
+        does (the pre-scan in ``_merge_source_lines`` uses the same rule).
+        """
+        if not isinstance(delimiter, str):
+            raise JCLSyntaxError(
+                f"DLM= must be a one- or two-character delimiter, got "
+                f"{jcl_value_text(delimiter)}",
+                line_num,
+            )
+        self.in_inline_data = True
+        self.inline_data_lines = []
+        self.current_delimiter = delimiter
+        self.current_terminates_on_slash = False
 
     # ------------------------------------------------------------------ #
     # Finalisation
@@ -767,7 +887,7 @@ class JobBuilder:
             return self.job
         if not self.pending_procedures:
             raise JCLSyntaxError("No JOB statement found", 0)
-        job = Job(name="", line_number=0)
+        job = Job(name="", line_number=0, is_procedure_member=True)
         for proc in self.pending_procedures:
             job.add_procedure(proc)
             # A JOB-less member (a cataloged procedure) has no job
@@ -805,6 +925,7 @@ class JobBuilder:
         job.conditionals[:0] = self.pending_conditionals
         job.steps[:0] = self.pending_steps
         job.control_statements[:0] = self.pending_control
+        job.custom_statements[:0] = self.pending_custom
 
     def _flush_pending_sets(self, job: Job) -> None:
         # Statements seen before the JOB statement (or in a JOB-less member)
@@ -820,11 +941,17 @@ class JobBuilder:
                 for k, v in (step.set_symbols or {}).items()
             ):
                 step.set_symbols = None
+        for procedure, step in self.procedure_steps:
+            if all(
+                procedure.set_statements.get(k) == v
+                for k, v in (step.set_symbols or {}).items()
+            ):
+                step.set_symbols = None
 
     def _warn_orphaned_dds(self, job: Job) -> None:
         # orphaned_dds is only ever non-empty here when the whole job had no
-        # EXEC statement at all (the first EXEC always flushes and clears the
-        # list) -- those DD statements have nowhere to attach and are
+        # job-level EXEC statement at all (the first one always flushes and
+        # clears the list) -- those DD statements have nowhere to attach and are
         # discarded, so record what was lost instead of vanishing them silently.
         if self.orphaned_dds:
             dd_names = ", ".join(dd.name or "(unnamed)" for dd in self.orphaned_dds)