jcl-parser 2.2.0__tar.gz → 2.2.1__tar.gz

{jcl_parser-2.2.0 → jcl_parser-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jcl-parser
-Version: 2.2.0
+Version: 2.2.1
 Summary: Parse IBM JCL (Job Control Language) scripts into Python objects
 Author-email: Samuel Dion <sam94dion@gmail.com>
 License-Expression: AGPL-3.0-or-later

{jcl_parser-2.2.0 → jcl_parser-2.2.1}/jcl_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jcl-parser
-Version: 2.2.0
+Version: 2.2.1
 Summary: Parse IBM JCL (Job Control Language) scripts into Python objects
 Author-email: Samuel Dion <sam94dion@gmail.com>
 License-Expression: AGPL-3.0-or-later

{jcl_parser-2.2.0 → jcl_parser-2.2.1}/jclparser/__init__.py

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

{jcl_parser-2.2.0 → jcl_parser-2.2.1}/jclparser/_job_builder.py

@@ -304,6 +304,24 @@ class JobBuilder:
             self.pending_jes_typed.append(jes3)
             self.pending_jes_statements.append(raw_text)
 
+    def handle_jes3_data(self, line: str) -> None:
+        """Keep a record of a JES3 ``//*DATASET`` with that statement.
+
+        The ``END=`` terminator record ends the data and is not kept.
+        """
+        from .jes_statements import Jes3ControlStatement
+
+        typed = self.job.jes_typed_statements if self.job else self.pending_jes_typed
+        for stmt in reversed(typed):
+            if (
+                isinstance(stmt, Jes3ControlStatement)
+                and stmt.name.upper() == "DATASET"
+            ):
+                terminator = stmt.parameters.get("END", "").strip("'")
+                if not (terminator and line.startswith(terminator)):
+                    stmt.data.append(line)
+                return
+
     # ------------------------------------------------------------------ #
     # Statement dispatch
     # ------------------------------------------------------------------ #

{jcl_parser-2.2.0 → jcl_parser-2.2.1}/jclparser/_source_scanner.py

@@ -52,11 +52,19 @@ class ScannedSource(NamedTuple):
     control_data_indices: set[int]
     #: Findings about records that were discarded or repaired.
     warnings: list[str]
+    #: 0-based indices of the records of a JES3 ``//*DATASET`` input data
+    #: set (between ``//*DATASET`` and ``//*ENDDATASET`` or its ``END=``
+    #: terminator, the terminator included when it is not ENDDATASET).
+    jes3_data_indices: frozenset[int] = frozenset()
 
 
-def _merge_source_lines(content: str) -> ScannedSource:
+def _merge_source_lines(content: str, dialect: str = "standard") -> ScannedSource:
     """Normalize, mark in-stream data, and merge continuation lines.
 
+    Under every dialect but ``jes2`` (where ``//*`` is only ever a comment),
+    the records of a JES3 ``//*DATASET`` ... ``//*ENDDATASET`` input data set
+    are data too (issue #162).
+
     Neither in-stream data nor CNTL control records may be parsed as JCL
     statements; the parse loop uses the returned index sets to route them.
     The warnings report an unterminated CNTL block and comment fields that
@@ -66,7 +74,7 @@ def _merge_source_lines(content: str) -> ScannedSource:
     raw_lines = split_source_lines(content)
     lines = normalize_jcl_lines(raw_lines)
 
-    classifier = _RecordClassifier(lines)
+    classifier = _RecordClassifier(lines, jes3_datasets=dialect != "jes2")
     jcl_indices = classifier.run()
 
     handler = ContinuationLineHandler()
@@ -84,11 +92,16 @@ def _merge_source_lines(content: str) -> ScannedSource:
     # raw record is woven in (trailing blanks aside) rather than the
     # normalized one (issue #115).  CNTL control records are statements
     # with JCL's column rules and stay normalized.
-    data_lines = {i: _data_record(raw_lines[i]) for i in classifier.inline_data_indices}
+    data_lines = {
+        i: _data_record(raw_lines[i])
+        for i in classifier.inline_data_indices | classifier.jes3_data_indices
+    }
     merged_lines = _weave_lines(
         lines,
         merged_start,
-        classifier.inline_data_indices | classifier.control_data_indices,
+        classifier.inline_data_indices
+        | classifier.control_data_indices
+        | classifier.jes3_data_indices,
         data_lines,
     )
 
@@ -113,6 +126,7 @@ def _merge_source_lines(content: str) -> ScannedSource:
         classifier.inline_data_indices,
         classifier.control_data_indices,
         warnings,
+        frozenset(classifier.jes3_data_indices),
     )
 
 
@@ -200,12 +214,19 @@ class _RecordClassifier:
     :attr:`control_data_indices` and :attr:`warnings`.
     """
 
-    def __init__(self, lines: list[str]) -> None:
+    def __init__(self, lines: list[str], *, jes3_datasets: bool = True) -> None:
         self.lines = lines
         self.inline_data_indices: set[int] = set()
         self.control_data_indices: set[int] = set()
+        self.jes3_data_indices: set[int] = set()
         self.warnings: list[str] = []
 
+        # JES3 ``//*DATASET``: the records up to ``//*ENDDATASET`` (or the
+        # ``END=`` terminator) are the content of an input data set.
+        self.jes3_datasets = jes3_datasets
+        self.jes3_terminator: str | None = None
+        self.jes3_start_line = 0
+
         self.in_inline_data = False
         self.delimiter = "/*"
         # When the current in-stream dataset was opened with ``DD *`` (and
@@ -228,10 +249,67 @@ class _RecordClassifier:
         self.pending: tuple[str, str] | None = None
 
     def run(self) -> list[int]:
-        return [i for i, line in enumerate(self.lines) if self._is_jcl(i, line)]
+        jcl = [i for i, line in enumerate(self.lines) if self._is_jcl(i, line)]
+        if self.jes3_terminator is not None:
+            self.warnings.append(
+                f"Line {self.jes3_start_line}: //*DATASET has no matching "
+                f"{self._jes3_terminator_name()}; its data runs to the end "
+                f"of the source"
+            )
+        return jcl
+
+    def _jes3_terminator_name(self) -> str:
+        return (
+            "//*ENDDATASET"
+            if self.jes3_terminator == _ENDDATASET
+            else f"END={self.jes3_terminator} terminator"
+        )
+
+    def _consume_jes3_data(self, i: int, line: str) -> bool:
+        """Handle a record inside a JES3 ``//*DATASET``; True if it was data.
+
+        The ``//*ENDDATASET`` record itself stays a JCL (JES3 control)
+        record; an ``END=`` terminator record is part of the data block.
+        """
+        if _jes3_command(line) == "ENDDATASET":
+            self.jes3_terminator = None
+            return False
+        if self.jes3_terminator != _ENDDATASET and line.startswith(
+            str(self.jes3_terminator)
+        ):
+            self.jes3_terminator = None
+        self.jes3_data_indices.add(i)
+        return True
+
+    def _opens_jes3_dataset(self, i: int, line: str) -> None:
+        """Note a ``//*DATASET`` record: data follows until its terminator.
+
+        A JES3 ``//*DATASET`` statement always codes ``DDNAME=``; without it
+        the record is an ordinary comment that happens to start with that
+        word (``//*DATASET DEFINITIONS FOR ...``) and opens no data (#164).
+        """
+        if not self.jes3_datasets or _jes3_command(line) != "DATASET":
+            return
+        terminator = _ENDDATASET
+        has_ddname = False
+        for param in line.strip()[3:].split(None, 1)[1:2]:
+            for item in param.split(None, 1)[0].split(","):
+                key, _, value = item.partition("=")
+                if key.upper() == "DDNAME" and value:
+                    has_ddname = True
+                if key.upper() == "END" and value.strip("'"):
+                    terminator = value.strip("'")
+        if not has_ddname:
+            return
+        self.jes3_terminator = terminator
+        self.jes3_start_line = i + 1
 
     def _is_jcl(self, i: int, line: str) -> bool:
         """Classify record *i*; return True if it is a JCL record."""
+        if self.jes3_terminator is not None and self._consume_jes3_data(i, line):
+            return False
+        if line.startswith("//*") and not self.in_inline_data:
+            self._opens_jes3_dataset(i, line)
         if self.in_inline_data and self._consume_inline_data(i, line):
             return False
         if self.in_cntl_block and self._consume_control_data(i, line):
@@ -371,6 +449,17 @@ class _RecordClassifier:
         return operation, operands
 
 
+#: Marks a ``//*DATASET`` whose data ends at ``//*ENDDATASET``.
+_ENDDATASET = "\0ENDDATASET"
+
+
+def _jes3_command(line: str) -> str | None:
+    """The command of a JES3 ``//*COMMAND`` record (no blank after ``//*``)."""
+    if not line.startswith("//*") or len(line) < 4 or line[3].isspace():
+        return None
+    return line[3:].split(None, 1)[0].upper()
+
+
 #: Statements whose operands can open a data block in the pre-scan.
 _DATA_OPENING_OPERATIONS = frozenset({"DD", "XMIT"})
 

{jcl_parser-2.2.0 → jcl_parser-2.2.1}/jclparser/checks.py

@@ -118,7 +118,41 @@ def _lint_file(
         if explode:
             job = job.explode()
     except _UNREADABLE as exc:
-        return FileReport(_uri(path), [_parse_failure(exc)])
+        bare = _bare_member_job(path)
+        if bare is None:
+            return FileReport(_uri(path), [_parse_failure(exc)])
+        job = bare
+    return _lint_one(path, job, config)
+
+
+def _bare_member_job(path: Path) -> Job | None:
+    """A PROC member with no PROC statement, as a job to lint, or None."""
+    from .lineage import _bare_procedure_member
+    from .lint.runner import procedure_body_job
+    from .model import iter_execution_steps
+
+    proc = _bare_procedure_member(path)
+    if proc is None:
+        return None
+    job = procedure_body_job(proc)
+    # The member was read behind a one-line JOB wrapper; give the findings
+    # the member's own line numbers.
+    for step in iter_execution_steps(job.steps):
+        step.line_number = max(step.line_number - 1, 0)
+        for dd in step.dd_statements:
+            dd.line_number = max(dd.line_number - 1, 0)
+    return job
+
+
+def _lint_member(path: Path, config: LintConfig) -> FileReport:
+    """Lint a PROC member found in a directory: its PROC bodies' steps."""
+    try:
+        job = parse_jcl(path, enable_external_procs=False)
+    except _UNREADABLE:
+        bare = _bare_member_job(path)
+        if bare is None:
+            raise
+        job = bare
     return _lint_one(path, job, config)
 
 
@@ -129,8 +163,8 @@ def _lint_directory(
     explode: bool,
     proc_base_path: str | None,
 ) -> list[FileReport]:
-    # load_job_stream explodes with the directory's own PROC members; the
-    # members themselves are not jobs and are not linted.
+    # load_job_stream explodes with the directory's own PROC members; each
+    # member is linted on its own too, for the steps of its PROC body.
     stream = load_job_stream(
         directory, pattern, explode=explode, proc_base_path=proc_base_path
     )
@@ -138,6 +172,9 @@ def _lint_directory(
         _lint_one(directory / job_id, job, config)
         for job_id, job in stream.jobs.items()
     ]
+    reports += [
+        _lint_member(directory / member_id, config) for member_id in stream.procedures
+    ]
     for job_id, message in stream.errors.items():
         failure = _parse_failure(ValueError(message))
         reports.append(FileReport(_uri(directory / job_id), [failure]))

{jcl_parser-2.2.0 → jcl_parser-2.2.1}/jclparser/explosion.py

@@ -21,6 +21,7 @@ from .errors import (
     ProcedureNotFoundError,
     UndefinedSymbolError,
 )
+from .include_loader import IncludeMemberLoader
 from .model import (
     ConditionalBlock,
     DDStatement,
@@ -1514,6 +1515,7 @@ def explode_job(
     audit: bool = True,
     system_provider: SystemSymbolProvider | None = None,
     strict_symbols: bool = False,
+    include_loader: IncludeMemberLoader | None = None,
 ) -> Job:
     """
     Explode all procedure invocations in a job.
@@ -1532,6 +1534,11 @@ def explode_job(
         audit: Whether to generate audit logs
         system_provider: System symbol provider (defaults to mock provider)
         strict_symbols: If True, raise errors for undefined symbols
+        include_loader: Loader for the ``// INCLUDE MEMBER=`` statements of
+                   a cataloged (external) PROC, searched in the job's JCLLIB
+                   order; defaults to the loader :func:`parse_jcl` read the
+                   job's own INCLUDEs with.  A member it cannot find is a
+                   job warning.
 
     Returns:
         New Job instance with exploded procedures
@@ -1547,8 +1554,11 @@ def explode_job(
     # the job's JCLLIB / proc_base_path (so an external PROC called from inside
     # another PROC or an IF block is found where the top-level ones were),
     # else the default chain. Inline procedures always win.
-    if proc_loader is None:
-        proc_loader = _job_proc_loader(job)
+    include_expander = _IncludeExpandingLoader(
+        proc_loader if proc_loader is not None else _job_proc_loader(job),
+        include_loader or _job_include_loader(job),
+    )
+    proc_loader = include_expander
 
     # Get system provider
     system_provider = system_provider or get_default_provider()
@@ -1640,6 +1650,7 @@ def explode_job(
     # copy in _exploded_job) -- e.g. an undefined &SYMBOL only resolvable
     # inside a PROC body.
     exploded_job.warnings.extend(explosion_warnings)
+    include_expander.record_on(exploded_job)
 
     # Attach audit metadata
     if audit:
@@ -1670,6 +1681,153 @@ def _job_step_scope(job: Job, step: Step, base_scope: SymbolScope) -> SymbolScop
     )
 
 
+def _job_include_loader(job: Job) -> IncludeMemberLoader:
+    """The INCLUDE loader :func:`parse_jcl` attached to *job*, else the
+    default filesystem one."""
+    from .include_loader import JCLLIBMemberLoader
+
+    loader: IncludeMemberLoader | None = getattr(job, "_include_loader", None)
+    return loader if loader is not None else JCLLIBMemberLoader()
+
+
+class _IncludeExpandingLoader(ProcedureLoader):
+    """*inner*, with the INCLUDEs of each external PROC it returns expanded.
+
+    ``parse_jcl`` expands INCLUDEs in the job text, in-stream PROCs
+    included, before parsing; a cataloged PROC is read later, so its
+    INCLUDEs are expanded here, against the job's JCLLIB order (issue #153).
+    :meth:`record_on` adds the members expanded to the exploded job's
+    ``includes`` and a warning for each member not found.
+    """
+
+    def __init__(
+        self, inner: ProcedureLoader, include_loader: IncludeMemberLoader
+    ) -> None:
+        self._inner = inner
+        self._include_loader = include_loader
+        self._included: list[str] = []
+        self._warnings: list[str] = []
+        self._cache: dict[tuple[str, tuple[str, ...] | None], Procedure | None] = {}
+        self._call_cache: dict[
+            tuple[str, tuple[str, ...] | None, tuple[tuple[str, str], ...]], Procedure
+        ] = {}
+
+    def load_procedure(
+        self, name: str, libraries: Sequence[str] | None = None
+    ) -> Procedure | None:
+        key = (name.upper(), tuple(libraries) if libraries else None)
+        if key not in self._cache:
+            proc = self._inner.load_procedure(name, libraries)
+            self._cache[key] = (
+                self._expanded(proc, libraries) if proc is not None else None
+            )
+        return self._cache[key]
+
+    def for_call(
+        self,
+        proc: Procedure,
+        libraries: Sequence[str] | None,
+        scope: SymbolScope,
+    ) -> Procedure:
+        """*proc* as one call of it sees it: INCLUDE member names written as
+        symbols (``MEMBER=&MEM``) resolved in that call's *scope* -- EXEC
+        values, PROC defaults, SETs (issue #160).
+
+        *proc* is returned as is when no INCLUDE of its text names a symbol.
+        """
+        text = proc.source_text
+        if not text or not _has_symbolic_include(text):
+            return proc
+        symbols = _flattened_caller_scope(scope).set_symbols
+        key = (
+            (proc.name or "").upper(),
+            tuple(libraries) if libraries else None,
+            tuple(sorted(symbols.items())),
+        )
+        if key not in self._call_cache:
+            self._call_cache[key] = self._expanded(proc, libraries, symbols)
+        return self._call_cache[key]
+
+    def record_on(self, job: Job) -> None:
+        job.warnings.extend(self._warnings)
+        job.includes.extend(m for m in self._included if m not in job.includes)
+
+    def _expanded(
+        self,
+        proc: Procedure,
+        libraries: Sequence[str] | None,
+        symbols: dict[str, str] | None = None,
+    ) -> Procedure:
+        """*proc* with the INCLUDEs of its text expanded.
+
+        Without *symbols* (the expansion at load time), an INCLUDE whose
+        member is a symbol is left for :meth:`for_call`, without a warning.
+        """
+        from ._statement_parser import _has_include_statement
+        from .include_loader import resolve_includes
+        from .proc_loader import _build_procedure_from_content
+
+        text = proc.source_text
+        if not proc.is_external or not text or not _has_include_statement(text):
+            return proc
+        members: list[str] = []
+        expanded_text = resolve_includes(
+            text,
+            self._include_loader,
+            list(libraries) if libraries else None,
+            _collected=members,
+            _symbols=dict(symbols) if symbols is not None else None,
+        )
+        self._warn_missing(proc, expanded_text, symbols)
+        self._included.extend(m for m in members if m not in self._included)
+        if not members:
+            return proc
+        rebuilt = _build_procedure_from_content(expanded_text, proc.name)
+        if rebuilt is None:
+            return proc
+        rebuilt.source_text = text
+        return rebuilt
+
+    def _warn_missing(
+        self, proc: Procedure, expanded_text: str, symbols: dict[str, str] | None
+    ) -> None:
+        """Warn once for each INCLUDE left in *expanded_text* (not found)."""
+        from .include_loader import (
+            _extract_include_member,
+            _record_set_symbols,
+            _substitute_member_symbols,
+        )
+        from .utils import split_source_lines
+
+        seen = dict(symbols) if symbols is not None else {}
+        for line in split_source_lines(expanded_text):
+            _record_set_symbols(line.rstrip(), seen)
+            missing = _extract_include_member(line.rstrip())
+            if not missing:
+                continue
+            if "&" in missing:
+                if symbols is None:
+                    continue
+                missing = _substitute_member_symbols(missing, seen)
+            warning = (
+                f"INCLUDE member {missing} in PROC {proc.name} not found; "
+                "its statements are missing from the exploded job"
+            )
+            if warning not in self._warnings:
+                self._warnings.append(warning)
+
+
+def _has_symbolic_include(text: str) -> bool:
+    """Whether an ``// INCLUDE`` statement of *text* names its member by symbol."""
+    from .include_loader import _extract_include_member
+    from .utils import split_source_lines
+
+    return any(
+        "&" in (_extract_include_member(line.rstrip()) or "")
+        for line in split_source_lines(text)
+    )
+
+
 def _job_proc_loader(job: Job) -> ProcedureLoader:
     """The loader :func:`explode_job` uses when the caller passes none."""
     job_loader: ProcedureLoader | None = getattr(job, "_proc_loader", None)
@@ -1828,6 +1986,41 @@ def _record_expansion(
         )
 
 
+def _load_called_procedure(
+    step: Step,
+    proc_loader: ProcedureLoader,
+    libraries: tuple[str, ...] | None,
+    base_scope: SymbolScope,
+    call_scope: SymbolScope | None,
+    strict_symbols: bool,
+    warnings: list[str] | None,
+) -> Procedure:
+    """The procedure PROC call *step* names, as that call sees it.
+
+    The call's still-unresolved overrides are resolved in the procedure's
+    scope when *call_scope* is given (see :func:`_explode_step`), then the
+    INCLUDEs naming their member by symbol are expanded in the call's scope.
+
+    Raises:
+        ProcedureNotFoundError: If *proc_loader* cannot find the procedure.
+    """
+    proc_name = step.procedure or ""
+    procedure = proc_loader.load_procedure(proc_name, libraries)
+    if procedure is None:
+        raise ProcedureNotFoundError(proc_name, step.line_number)
+    if call_scope is not None:
+        _resolve_call_in_proc_scope(
+            step, procedure, call_scope, strict_symbols, warnings
+        )
+    if isinstance(proc_loader, _IncludeExpandingLoader):
+        procedure = proc_loader.for_call(
+            procedure,
+            libraries,
+            _expansion_scope(procedure, step.parameters, base_scope),
+        )
+    return procedure
+
+
 def _explode_step(
     step: Step,
     proc_loader: ProcedureLoader,
@@ -1906,15 +2099,9 @@ def _explode_step(
     # against the job's library order. Pass an immutable tuple: loaders key their
     # caches on the library list, so a hashable value keeps that contract safe.
     _libs = tuple(jcllib_order) if jcllib_order else None
-    procedure = proc_loader.load_procedure(proc_name, _libs)
-
-    if procedure is None:
-        raise ProcedureNotFoundError(proc_name, step.line_number)
-
-    if call_scope is not None:
-        _resolve_call_in_proc_scope(
-            step, procedure, call_scope, strict_symbols, warnings
-        )
+    procedure = _load_called_procedure(
+        step, proc_loader, _libs, base_scope, call_scope, strict_symbols, warnings
+    )
 
     # Extract parameter overrides from step
     overrides = step.parameters.copy()

{jcl_parser-2.2.0 → jcl_parser-2.2.1}/jclparser/include_loader.py

@@ -324,8 +324,12 @@ class _IncludeExpander:
         # stay as-is. They are located with the same scan the parser uses.
         from ._source_scanner import _merge_source_lines
 
-        _, inline_data, control_data, _ = _merge_source_lines(content)
-        data_indices = inline_data | control_data
+        scanned = _merge_source_lines(content)
+        data_indices = (
+            scanned.inline_data_indices
+            | scanned.control_data_indices
+            | scanned.jes3_data_indices
+        )
 
         result: list[_Entry] = []
         for index, line in enumerate(lines):

{jcl_parser-2.2.0 → jcl_parser-2.2.1}/jclparser/jes_statements.py

@@ -48,6 +48,9 @@ class Jes3ControlStatement(JESControlStatement):
     """
 
     parameters: dict[str, str] = field(default_factory=dict)
+    #: For ``//*DATASET``: the records of the input data set, as coded, up
+    #: to ``//*ENDDATASET`` (or the ``END=`` terminator, which is not kept).
+    data: list[str] = field(default_factory=list)
 
 
 @dataclass

{jcl_parser-2.2.0 → jcl_parser-2.2.1}/jclparser/lineage.py

@@ -444,6 +444,29 @@ def _member_procedures(path: Path, member: Job) -> dict[str, Procedure]:
     return procs
 
 
+def _bare_procedure_member(path: Path) -> Procedure | None:
+    """*path* read as a cataloged PROC member with no ``PROC`` statement.
+
+    On z/OS the PROC statement of a cataloged procedure is optional (it only
+    gives symbolic parameters defaults), so a member may start at its first
+    ``EXEC``.  :func:`parse_jcl` rejects such a JOB-less file ("EXEC
+    statement before JOB statement"); the file-based PROC loader reads it as
+    the body of a procedure named after the member, and so does this
+    (issue #147).  None when *path* is not such a member.
+    """
+    from .jcl_file_type import FileType, detect_file_type_from_content
+    from .proc_loader import _build_procedure_from_content
+    from .utils import _read_file_with_fallback
+
+    try:
+        content = _read_file_with_fallback(path)
+        if detect_file_type_from_content(content) != FileType.PROC:
+            return None
+        return _build_procedure_from_content(content, path.stem.upper())
+    except (JCLParseError, OSError, UnicodeError, ValueError):
+        return None
+
+
 def load_job_stream(
     directory: str | Path,
     pattern: str = "*",
@@ -456,8 +479,9 @@ def load_job_stream(
     *pattern* is a :meth:`pathlib.Path.glob` pattern (``"**/*.jcl"`` recurses).
     Hidden files are skipped.  A file that fails to parse is recorded in
     :attr:`JobStream.errors` rather than raised; a JOB-less PROC member is
-    listed in :attr:`JobStream.procedures`.  With *explode* (the default)
-    each job's PROC calls are expanded: a PROC is looked up in the job
+    listed in :attr:`JobStream.procedures`, and so is a member with no
+    ``PROC`` statement that starts at its first ``EXEC`` (issue #147).  With
+    *explode* (the default) each job's PROC calls are expanded: a PROC is looked up in the job
     itself, then among the PROC members of the directory (by member name,
     see :func:`_member_procedures`; issue #144), then in *proc_base_path* as
     :func:`parse_jcl` does, then among the built-in PROCs.  A job whose
@@ -482,7 +506,12 @@ def load_job_stream(
                 enable_external_procs=proc_base_path is not None,
             )
         except (JCLParseError, UnicodeError, ValueError) as exc:
-            stream.errors[job_id] = _first_line(str(exc))
+            bare = _bare_procedure_member(path)
+            if bare is None:
+                stream.errors[job_id] = _first_line(str(exc))
+            else:
+                stream.procedures.append(job_id)
+                members.setdefault(path.stem.upper(), bare)
             continue
         if job.is_procedure_member:
             stream.procedures.append(job_id)