jcl-parser 1.2.1__tar.gz → 1.3.0__tar.gz

{jcl_parser-1.2.1 → jcl_parser-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jcl-parser
-Version: 1.2.1
+Version: 1.3.0
 Summary: Parse IBM JCL (Job Control Language) scripts into Python objects
 Author-email: JCL Parser Team <team@jclparser.dev>
 License: END-USER LICENSE AGREEMENT (EULA)

{jcl_parser-1.2.1 → jcl_parser-1.3.0}/jcl_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jcl-parser
-Version: 1.2.1
+Version: 1.3.0
 Summary: Parse IBM JCL (Job Control Language) scripts into Python objects
 Author-email: JCL Parser Team <team@jclparser.dev>
 License: END-USER LICENSE AGREEMENT (EULA)

{jcl_parser-1.2.1 → jcl_parser-1.3.0}/jcl_parser.egg-info/SOURCES.txt

@@ -46,12 +46,23 @@ jclparser/plugins/__init__.py
 jclparser/plugins/base.py
 jclparser/program_profiles/__init__.py
 jclparser/program_profiles/_invoked.py
+jclparser/program_profiles/adrdssu.py
 jclparser/program_profiles/base.py
+jclparser/program_profiles/binder.py
+jclparser/program_profiles/compilers.py
 jclparser/program_profiles/db2_batch.py
 jclparser/program_profiles/dfsrrc00.py
+jclparser/program_profiles/ftp.py
+jclparser/program_profiles/icetool.py
 jclparser/program_profiles/idcams.py
+jclparser/program_profiles/iebdg.py
 jclparser/program_profiles/iebgener.py
+jclparser/program_profiles/iebptpch.py
+jclparser/program_profiles/iebupdte.py
 jclparser/program_profiles/iefbr14.py
+jclparser/program_profiles/iehlist.py
+jclparser/program_profiles/iehprogm.py
 jclparser/program_profiles/ikjeft01.py
+jclparser/program_profiles/irxjcl.py
 jclparser/program_profiles/registry.py
 jclparser/program_profiles/sort.py

jcl_parser-1.3.0/jclparser/program_profiles/adrdssu.py

@@ -0,0 +1,72 @@
+"""Profile for ``ADRDSSU`` — DFSMSdss batch (DUMP/RESTORE/COPY).
+
+Control statements are read from ``SYSIN`` and use a keyword-command form,
+e.g. ``DUMP DATASET(INCLUDE(...)) OUTDDNAME(...)``.  This is a shallow
+parse: it recognises the leading command keyword and, where present, the
+``DATASET(INCLUDE(...))`` dataset list, without validating the full
+DFSMSdss grammar (which spans many optional sub-parameters).
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .base import ProgramAnalysis, ProgramProfile, _sysin_text
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+_COMMANDS = (
+    "DUMP",
+    "RESTORE",
+    "COPY",
+    "RELEASE",
+    "COMPRESS",
+    "DEFRAG",
+    "CONVERTV",
+    "PRINT",
+)
+_RE_COMMAND = re.compile(
+    r"^\s*(" + "|".join(_COMMANDS) + r")\b", re.IGNORECASE | re.MULTILINE
+)
+_RE_DATASET_INCLUDE = re.compile(
+    r"DATASET\s*\(\s*INCLUDE\s*\(\s*([^)]*)\)", re.IGNORECASE
+)
+
+
+class ADRDSSUProfile(ProgramProfile):
+    program_names = frozenset({"ADRDSSU"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        text = _sysin_text(step) or ""
+        notes: list[str] = []
+
+        matches = list(_RE_COMMAND.finditer(text))
+        for i, m in enumerate(matches):
+            command = m.group(1).upper()
+            # Scope the INCLUDE search to this command's own statement —
+            # up to the next command keyword (or end of text) — so a later
+            # command's DATASET(INCLUDE(...)) can't be misattributed here.
+            segment_end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+            segment = text[m.end() : segment_end]
+            ds_m = _RE_DATASET_INCLUDE.search(segment)
+            if ds_m:
+                names = [n.strip() for n in ds_m.group(1).split() if n.strip()]
+                notes.append(f"{command} DATASET(INCLUDE({' '.join(names)}))")
+            else:
+                notes.append(command)
+
+        summary = (
+            f"ADRDSSU: {len(notes)} command(s)"
+            if notes
+            else "ADRDSSU with no recognised commands"
+        )
+        return ProgramAnalysis(
+            program="ADRDSSU",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=[],
+            notes=notes,
+            raw_control=text or None,
+        )

jcl_parser-1.3.0/jclparser/program_profiles/binder.py

@@ -0,0 +1,73 @@
+"""Profile for ``IEWL`` / ``HEWL`` — the Binder / Linkage Editor.
+
+Control statements are read from ``SYSIN`` (or, when absent, ``SYSLIN``):
+``INCLUDE`` pulls in an object/load module, ``ENTRY`` sets the entry point,
+``NAME`` names the output load module member, and ``LIBRARY``/``ALIAS``
+add search libraries and alternate names.  Output lands on ``SYSLMOD``.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .base import ProgramAnalysis, ProgramProfile
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+_RE_INCLUDE = re.compile(
+    r"^\s*INCLUDE\s+([A-Za-z0-9$#@]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_ENTRY = re.compile(r"^\s*ENTRY\s+([A-Za-z0-9$#@]+)", re.IGNORECASE | re.MULTILINE)
+_RE_NAME = re.compile(r"^\s*NAME\s+([A-Za-z0-9$#@]+)", re.IGNORECASE | re.MULTILINE)
+_RE_LIBRARY = re.compile(
+    r"^\s*LIBRARY\s+([A-Za-z0-9$#@,()]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_ALIAS = re.compile(r"^\s*ALIAS\s+([A-Za-z0-9$#@]+)", re.IGNORECASE | re.MULTILINE)
+
+
+def _control_text(step: Step) -> str:
+    for dd_name in ("SYSIN", "SYSLIN"):
+        dd = step.get_dd(dd_name)
+        if dd and dd.inline_data:
+            return dd.inline_data
+    return ""
+
+
+class BinderProfile(ProgramProfile):
+    program_names = frozenset({"IEWL", "HEWL"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        text = _control_text(step)
+        notes: list[str] = []
+
+        includes = [m.group(1) for m in _RE_INCLUDE.finditer(text)]
+        if includes:
+            notes.append(f"INCLUDE {', '.join(includes)}")
+        for m in _RE_ENTRY.finditer(text):
+            notes.append(f"ENTRY {m.group(1)}")
+        for m in _RE_NAME.finditer(text):
+            notes.append(f"NAME {m.group(1)}")
+        for m in _RE_LIBRARY.finditer(text):
+            notes.append(f"LIBRARY {m.group(1)}")
+        for m in _RE_ALIAS.finditer(text):
+            notes.append(f"ALIAS {m.group(1)}")
+
+        syslmod = step.get_dd("SYSLMOD")
+        if syslmod and syslmod.dataset_name:
+            notes.append(f"output module: {syslmod.dataset_name}")
+
+        summary = (
+            f"{step.program}: link-edits {len(includes)} object module(s)"
+            if notes
+            else f"{step.program} with no recognised control statements"
+        )
+        return ProgramAnalysis(
+            program=step.program or "IEWL",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=[],
+            notes=notes,
+            raw_control=text or None,
+        )

jcl_parser-1.3.0/jclparser/program_profiles/compilers.py

@@ -0,0 +1,67 @@
+"""Profile for language-translator (compiler) steps.
+
+Covers the common z/OS compilers invoked directly via ``EXEC PGM=``:
+COBOL (``IGYCRCTL``), PL/I (``IEL1CL``, ``IBMZPLI``), and High Level
+Assembler (``ASMA90``).  These programs do not read a command-language
+control stream the way utilities do — the "control" is the source itself
+on ``SYSIN`` plus copybook/include libraries on ``SYSLIB``.  The profile
+reports which of those DDs are present and where the compiled object
+lands (``SYSLIN``/``SYSPUNCH``), which is enough to model a compile step's
+dataset dependencies without parsing the source language.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .base import ProgramAnalysis, ProgramProfile
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+_COMPILER_LABELS = {
+    "IGYCRCTL": "COBOL",
+    "IEL1CL": "PL/I",
+    "IBMZPLI": "PL/I",
+    "ASMA90": "Assembler",
+}
+
+
+class CompilerProfile(ProgramProfile):
+    program_names = frozenset(_COMPILER_LABELS)
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        program = step.program or ""
+        language = _COMPILER_LABELS.get(program.upper(), "")
+        notes: list[str] = []
+
+        sysin = step.get_dd("SYSIN")
+        if sysin and sysin.dataset_name:
+            notes.append(f"source: {sysin.dataset_name}")
+        elif sysin and sysin.inline_data:
+            notes.append("source: in-stream SYSIN")
+
+        syslib = step.get_dd("SYSLIB")
+        if syslib and syslib.dataset_name:
+            notes.append(f"copy/include library: {syslib.dataset_name}")
+
+        for out_dd in ("SYSLIN", "SYSPUNCH"):
+            dd = step.get_dd(out_dd)
+            if dd and dd.dataset_name:
+                notes.append(f"object output ({out_dd}): {dd.dataset_name}")
+
+        summary = (
+            f"{language} compile ({program})" if language else f"compile ({program})"
+        )
+        if notes:
+            summary += f": {len(notes)} relevant DD(s)"
+        else:
+            summary += " with no recognised SYSIN/SYSLIB/SYSLIN DDs"
+
+        return ProgramAnalysis(
+            program=program or "COMPILER",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=[],
+            notes=notes,
+        )

jcl_parser-1.3.0/jclparser/program_profiles/ftp.py

@@ -0,0 +1,59 @@
+"""Profile for batch ``FTP`` (``PGM=FTP``).
+
+z/OS batch FTP jobs drive the client from ``SYSIN`` subcommands: ``OPEN``
+names the remote host, ``USER`` authenticates, ``PUT``/``GET``/``MPUT``/
+``MGET`` transfer files, and ``ASCII``/``BINARY`` set transfer mode. The
+profile surfaces the host and the file operations without attempting to
+resolve remote paths.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .base import ProgramAnalysis, ProgramProfile, _sysin_text
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+_RE_OPEN = re.compile(r"^\s*OPEN\s+(\S+)", re.IGNORECASE | re.MULTILINE)
+_RE_USER = re.compile(r"^\s*USER\s+(\S+)", re.IGNORECASE | re.MULTILINE)
+_RE_TRANSFER = re.compile(
+    r"^\s*(PUT|GET|MPUT|MGET)\s+(\S+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_MODE = re.compile(r"^\s*(ASCII|BINARY)\b", re.IGNORECASE | re.MULTILINE)
+
+
+class FTPProfile(ProgramProfile):
+    program_names = frozenset({"FTP"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        text = _sysin_text(step) or ""
+        notes: list[str] = []
+
+        host_m = _RE_OPEN.search(text)
+        if host_m:
+            notes.append(f"OPEN {host_m.group(1)}")
+        user_m = _RE_USER.search(text)
+        if user_m:
+            notes.append(f"USER {user_m.group(1)}")
+        for m in _RE_TRANSFER.finditer(text):
+            notes.append(f"{m.group(1).upper()} {m.group(2)}")
+        mode_m = _RE_MODE.search(text)
+        if mode_m:
+            notes.append(mode_m.group(1).upper())
+
+        summary = (
+            f"FTP: {len(notes)} subcommand(s)"
+            if notes
+            else "FTP with no recognised SYSIN subcommands"
+        )
+        return ProgramAnalysis(
+            program="FTP",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=[],
+            notes=notes,
+            raw_control=text or None,
+        )

jcl_parser-1.3.0/jclparser/program_profiles/icetool.py

@@ -0,0 +1,94 @@
+"""Profile for ``ICETOOL`` — the DFSORT batch toolkit.
+
+ICETOOL reads a sequence of operator statements from ``TOOLIN`` (one
+operator per logical statement), each naming its input/output DDs via
+``FROM(ddname)`` / ``TO(ddname)`` / ``USING(member)``.  Common operators:
+``COPY``, ``SORT``, ``MERGE``, ``COUNT``, ``STATS``, ``SELECT``, ``SPLICE``,
+``UNIQUE``, ``OCCUR``, ``DISPLAY``, ``DEFAULTS``, ``MODE``, ``RESIZE``,
+``VERIFY``, ``WHENSAME``, ``WHENDIFF``, ``DEDUP``, ``RANGE``, ``CORR``.
+
+Like :mod:`jclparser.program_profiles.sort`, this is a shallow parse: it
+surfaces which operators ran and which DDs they touched without validating
+field specifications.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .base import ProgramAnalysis, ProgramProfile, _sysin_text
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+_OPERATORS = (
+    "COPY",
+    "SORT",
+    "MERGE",
+    "COUNT",
+    "STATS",
+    "SELECT",
+    "SPLICE",
+    "UNIQUE",
+    "OCCUR",
+    "DISPLAY",
+    "DEFAULTS",
+    "MODE",
+    "RESIZE",
+    "VERIFY",
+    "WHENSAME",
+    "WHENDIFF",
+    "DEDUP",
+    "RANGE",
+    "CORR",
+)
+_RE_OPERATOR_LINE = re.compile(
+    r"^\s*(" + "|".join(_OPERATORS) + r")\b(.*)$",
+    re.IGNORECASE | re.MULTILINE,
+)
+_RE_FROM = re.compile(r"\bFROM\s*\(\s*([A-Za-z0-9$#@]+)\s*\)", re.IGNORECASE)
+_RE_TO = re.compile(r"\bTO\s*\(\s*([A-Za-z0-9$#@]+)\s*\)", re.IGNORECASE)
+
+
+def _toolin_text(step: Step) -> str:
+    dd = step.get_dd("TOOLIN")
+    if dd and dd.inline_data:
+        return dd.inline_data
+    # Some jobs route TOOLIN through SYSIN instead.
+    return _sysin_text(step) or ""
+
+
+class ICETOOLProfile(ProgramProfile):
+    program_names = frozenset({"ICETOOL"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        text = _toolin_text(step)
+        notes: list[str] = []
+
+        for m in _RE_OPERATOR_LINE.finditer(text):
+            operator = m.group(1).upper()
+            tail = m.group(2)
+            froms = _RE_FROM.findall(tail)
+            tos = _RE_TO.findall(tail)
+            parts = []
+            if froms:
+                parts.append(f"FROM({','.join(froms)})")
+            if tos:
+                parts.append(f"TO({','.join(tos)})")
+            detail = f" {' '.join(parts)}" if parts else ""
+            notes.append(f"{operator}{detail}")
+
+        summary = (
+            f"ICETOOL: {len(notes)} operator(s)"
+            if notes
+            else "ICETOOL with no recognised TOOLIN operators"
+        )
+        return ProgramAnalysis(
+            program="ICETOOL",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=[],
+            notes=notes,
+            raw_control=text or None,
+        )

jcl_parser-1.3.0/jclparser/program_profiles/iebdg.py

@@ -0,0 +1,58 @@
+"""Profile for ``IEBDG`` — test data generator.
+
+Control statements are read from ``SYSIN``: ``DSD`` names the output
+dataset description, ``FD`` describes a field, and ``CREATE`` requests
+record generation (optionally with a ``REPEAT`` count sub-parameter). The
+generated output lands on ``SYSUT2``, referenced by DDNAME= on the DSD
+statement or the step's SYSUT2 DD.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .base import ProgramAnalysis, ProgramProfile, _sysin_text
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+_RE_DSD = re.compile(
+    r"^\s*DSD\b[^\n]*DDNAME=([A-Za-z0-9$#@]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_FD = re.compile(
+    r"^\s*FD\b[^\n]*NAME=([A-Za-z0-9$#@]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_CREATE = re.compile(
+    r"^\s*CREATE\b(?:[^\n]*\bREPEAT=(\d+))?", re.IGNORECASE | re.MULTILINE
+)
+
+
+class IEBDGProfile(ProgramProfile):
+    program_names = frozenset({"IEBDG"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        text = _sysin_text(step) or ""
+        notes: list[str] = []
+
+        for m in _RE_DSD.finditer(text):
+            notes.append(f"DSD DDNAME={m.group(1)}")
+        field_names = [m.group(1) for m in _RE_FD.finditer(text)]
+        if field_names:
+            notes.append(f"FD fields: {', '.join(field_names)}")
+        for m in _RE_CREATE.finditer(text):
+            notes.append(f"CREATE REPEAT={m.group(1)}" if m.group(1) else "CREATE")
+
+        summary = (
+            f"IEBDG: generates test data ({len(field_names)} field(s))"
+            if notes
+            else "IEBDG with no recognised control statements"
+        )
+        return ProgramAnalysis(
+            program="IEBDG",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=[],
+            notes=notes,
+            raw_control=text or None,
+        )

{jcl_parser-1.2.1 → jcl_parser-1.3.0}/jclparser/program_profiles/iebgener.py

@@ -1,4 +1,5 @@
-"""Profiles for simple IBM copy utilities: ``IEBGENER`` and ``IEBCOPY``.
+"""Profiles for simple IBM copy utilities: ``IEBGENER``, ``IEBCOPY``, and
+``ICEGENER`` (the DFSORT-based drop-in replacement for IEBGENER).
 
 These programs copy data from one dataset to another.  The profile reports
 SYSUT1 (input) and SYSUT2 (output) as the canonical source/destination pair
@@ -8,27 +9,29 @@ dispositions.
 
 from __future__ import annotations
 
-from .base import ProgramProfile, ProgramAnalysis
-from ..dataset_lifecycle import DatasetEvent
+from typing import TYPE_CHECKING
 
+from ..dataset_lifecycle import DatasetEvent, _parse_disp_tokens
+from .base import ProgramAnalysis, ProgramProfile
 
-def _copy_utility_analysis(step, program: str) -> ProgramAnalysis:
+if TYPE_CHECKING:
+    from ..model import Step
+
+
+def _copy_utility_analysis(step: Step, program: str) -> ProgramAnalysis:
     sysut1 = step.get_dd("SYSUT1")
     sysut2 = step.get_dd("SYSUT2")
     events: list[DatasetEvent] = []
     notes: list[str] = []
 
     if sysut1 and sysut1.dataset_name:
+        status, _, _ = _parse_disp_tokens(sysut1.disposition)
         events.append(
             DatasetEvent(
                 step_name=step.name or "",
                 dd_name="SYSUT1",
                 action="OPEN_SHARED",
-                disp_status=(sysut1.disposition or "SHR")
-                .split(",")[0]
-                .strip("()")
-                .upper()
-                or "SHR",
+                disp_status=status or "SHR",
                 line_number=sysut1.line_number,
             )
         )
@@ -63,12 +66,19 @@ def _copy_utility_analysis(step, program: str) -> ProgramAnalysis:
 class IEBGENERProfile(ProgramProfile):
     program_names = frozenset({"IEBGENER"})
 
-    def analyze(self, step) -> ProgramAnalysis:
+    def analyze(self, step: Step) -> ProgramAnalysis:
         return _copy_utility_analysis(step, "IEBGENER")
 
 
 class IEBCOPYProfile(ProgramProfile):
     program_names = frozenset({"IEBCOPY"})
 
-    def analyze(self, step) -> ProgramAnalysis:
+    def analyze(self, step: Step) -> ProgramAnalysis:
         return _copy_utility_analysis(step, "IEBCOPY")
+
+
+class ICEGENERProfile(ProgramProfile):
+    program_names = frozenset({"ICEGENER"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        return _copy_utility_analysis(step, "ICEGENER")

jcl_parser-1.3.0/jclparser/program_profiles/iebptpch.py

@@ -0,0 +1,60 @@
+"""Profile for ``IEBPTPCH`` — sequential/PDS print & punch utility.
+
+Control statements are read from ``SYSIN``: ``PRINT`` or ``PUNCH`` selects
+the mode, ``TITLE`` supplies a report heading, ``MEMBER`` selects a PDS
+member, and ``RECORD`` narrows the field range printed/punched.  Input
+comes from ``SYSUT1``; output goes to ``SYSUT2``.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .base import ProgramAnalysis, ProgramProfile, _sysin_text
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+_RE_MODE = re.compile(r"^\s*(PRINT|PUNCH)\b", re.IGNORECASE | re.MULTILINE)
+_RE_MEMBER = re.compile(
+    r"^\s*MEMBER\s+NAME=([A-Za-z0-9$#@]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_TITLE = re.compile(r"^\s*TITLE\b", re.IGNORECASE | re.MULTILINE)
+_RE_RECORD = re.compile(r"^\s*RECORD\b", re.IGNORECASE | re.MULTILINE)
+
+
+class IEBPTPCHProfile(ProgramProfile):
+    program_names = frozenset({"IEBPTPCH"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        text = _sysin_text(step) or ""
+        notes: list[str] = []
+
+        mode_m = _RE_MODE.search(text)
+        if mode_m:
+            notes.append(mode_m.group(1).upper())
+        for m in _RE_MEMBER.finditer(text):
+            notes.append(f"MEMBER {m.group(1)}")
+        if _RE_TITLE.search(text):
+            notes.append("TITLE")
+        if _RE_RECORD.search(text):
+            notes.append("RECORD (field selection)")
+
+        sysut1 = step.get_dd("SYSUT1")
+        if sysut1 and sysut1.dataset_name:
+            notes.append(f"reads {sysut1.dataset_name}")
+
+        summary = (
+            f"IEBPTPCH: {len(notes)} control clause(s)"
+            if notes
+            else "IEBPTPCH with no recognised control statements"
+        )
+        return ProgramAnalysis(
+            program="IEBPTPCH",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=[],
+            notes=notes,
+            raw_control=text or None,
+        )

jcl_parser-1.3.0/jclparser/program_profiles/iebupdte.py

@@ -0,0 +1,76 @@
+"""Profile for ``IEBUPDTE`` — sequential/PDS member update utility.
+
+Control statements in ``SYSIN`` start with ``./`` (a change-control
+statement, not a JCL statement) and use ``./ ADD``, ``./ CHANGE``,
+``./ REPL``, and ``./ NUMBER``, typically with a ``NAME=member`` operand.
+The profile reports the base input (SYSUT1, when present), the output
+(SYSUT2), and which member operations the control stream requests.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from ..dataset_lifecycle import DatasetEvent, _parse_disp_tokens
+from .base import ProgramAnalysis, ProgramProfile, _sysin_text
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+_RE_CTL = re.compile(
+    r"^\./\s*(ADD|CHANGE|REPL|NUMBER)\b(?:[^\n]*\bNAME=([A-Za-z0-9$#@]+))?",
+    re.IGNORECASE | re.MULTILINE,
+)
+
+
+class IEBUPDTEProfile(ProgramProfile):
+    program_names = frozenset({"IEBUPDTE"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        text = _sysin_text(step) or ""
+        notes: list[str] = []
+
+        for m in _RE_CTL.finditer(text):
+            action = m.group(1).upper()
+            member = m.group(2)
+            notes.append(f"{action} NAME={member}" if member else action)
+
+        events: list[DatasetEvent] = []
+        sysut1 = step.get_dd("SYSUT1")
+        sysut2 = step.get_dd("SYSUT2")
+        if sysut1 and sysut1.dataset_name:
+            status, _, _ = _parse_disp_tokens(sysut1.disposition)
+            events.append(
+                DatasetEvent(
+                    step_name=step.name or "",
+                    dd_name="SYSUT1",
+                    action="OPEN_SHARED",
+                    disp_status=status or "SHR",
+                    line_number=sysut1.line_number,
+                )
+            )
+        if sysut2 and sysut2.dataset_name:
+            events.append(
+                DatasetEvent(
+                    step_name=step.name or "",
+                    dd_name="SYSUT2",
+                    action="ALLOCATE",
+                    disp_status="NEW",
+                    line_number=sysut2.line_number,
+                )
+            )
+
+        summary = (
+            f"IEBUPDTE: {len(notes)} member operation(s)"
+            if notes
+            else "IEBUPDTE with no recognised control statements"
+        )
+        return ProgramAnalysis(
+            program="IEBUPDTE",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=events,
+            notes=notes,
+            raw_control=text or None,
+        )

jcl_parser-1.3.0/jclparser/program_profiles/iehlist.py

@@ -0,0 +1,54 @@
+"""Profile for ``IEHLIST`` — VTOC / PDS directory listing utility.
+
+Control statements are read from ``SYSIN``: ``LISTVTOC``, ``LISTPDS``, and
+``LISTDG`` (the latter also usable as ``LISTIDG``).  IEHLIST is read-only —
+it never mutates a dataset — so the profile only reports which listing
+commands ran and, where present, the volume/dataset they target.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from .base import ProgramAnalysis, ProgramProfile, _sysin_text
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+_RE_LISTVTOC = re.compile(
+    r"^\s*LISTVTOC\b[^\n]*VOL=([A-Za-z0-9,=]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_LISTPDS = re.compile(
+    r"^\s*LISTPDS\b[^\n]*DSNAME=([A-Za-z0-9.$#@]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_LISTDG = re.compile(r"^\s*LIST(?:I)?DG\b", re.IGNORECASE | re.MULTILINE)
+
+
+class IEHLISTProfile(ProgramProfile):
+    program_names = frozenset({"IEHLIST"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        text = _sysin_text(step) or ""
+        notes: list[str] = []
+
+        for m in _RE_LISTVTOC.finditer(text):
+            notes.append(f"LISTVTOC VOL={m.group(1)}")
+        for m in _RE_LISTPDS.finditer(text):
+            notes.append(f"LISTPDS DSNAME={m.group(1)}")
+        for _ in _RE_LISTDG.finditer(text):
+            notes.append("LISTDG")
+
+        summary = (
+            f"IEHLIST: {len(notes)} listing command(s)"
+            if notes
+            else "IEHLIST with no recognised commands"
+        )
+        return ProgramAnalysis(
+            program="IEHLIST",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=[],
+            notes=notes,
+            raw_control=text or None,
+        )

jcl_parser-1.3.0/jclparser/program_profiles/iehprogm.py

@@ -0,0 +1,108 @@
+"""Profile for ``IEHPROGM`` — catalog/VTOC maintenance utility.
+
+Control statements are read from ``SYSIN``: ``SCRATCH`` (delete),
+``RENAME``, ``CATLG``, ``UNCATLG``, ``BLDG``, and ``CONNECT``.  Unlike the
+read-only listing in IEHLIST, several of these commands mutate the catalog,
+so — like :mod:`jclparser.program_profiles.idcams` — the profile emits
+:class:`~jclparser.dataset_lifecycle.DatasetEvent` entries for
+``SCRATCH``/``CATLG``/``UNCATLG``.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from ..dataset_lifecycle import DatasetEvent
+from .base import ProgramAnalysis, ProgramProfile, _sysin_text
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+_RE_SCRATCH = re.compile(
+    r"^\s*SCRATCH\b[^\n]*DSNAME=([A-Za-z0-9.$#@]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_RENAME = re.compile(
+    r"^\s*RENAME\b[^\n]*DSNAME=([A-Za-z0-9.$#@]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_CATLG = re.compile(
+    r"^\s*CATLG\b[^\n]*DSNAME=([A-Za-z0-9.$#@]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_UNCATLG = re.compile(
+    r"^\s*UNCATLG\b[^\n]*DSNAME=([A-Za-z0-9.$#@]+)", re.IGNORECASE | re.MULTILINE
+)
+_RE_BLDG = re.compile(r"^\s*BLDG\b", re.IGNORECASE | re.MULTILINE)
+_RE_CONNECT = re.compile(r"^\s*CONNECT\b", re.IGNORECASE | re.MULTILINE)
+
+
+class IEHPROGMProfile(ProgramProfile):
+    program_names = frozenset({"IEHPROGM"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        text = _sysin_text(step) or ""
+        events: list[DatasetEvent] = []
+        notes: list[str] = []
+
+        for m in _RE_SCRATCH.finditer(text):
+            dsn = m.group(1)
+            events.append(
+                DatasetEvent(
+                    step_name=step.name or "",
+                    dd_name="SYSIN",
+                    action="DELETE",
+                    disp_status="OLD",
+                    disp_normal="DELETE",
+                    line_number=step.line_number,
+                )
+            )
+            notes.append(f"SCRATCH {dsn}")
+
+        for m in _RE_RENAME.finditer(text):
+            notes.append(f"RENAME {m.group(1)}")
+
+        for m in _RE_CATLG.finditer(text):
+            dsn = m.group(1)
+            events.append(
+                DatasetEvent(
+                    step_name=step.name or "",
+                    dd_name="SYSIN",
+                    action="ALLOCATE",
+                    disp_status="NEW",
+                    disp_normal="CATLG",
+                    line_number=step.line_number,
+                )
+            )
+            notes.append(f"CATLG {dsn}")
+
+        for m in _RE_UNCATLG.finditer(text):
+            dsn = m.group(1)
+            events.append(
+                DatasetEvent(
+                    step_name=step.name or "",
+                    dd_name="SYSIN",
+                    action="UNCATALOG",
+                    disp_status="OLD",
+                    disp_normal="UNCATLG",
+                    line_number=step.line_number,
+                )
+            )
+            notes.append(f"UNCATLG {dsn}")
+
+        if _RE_BLDG.search(text):
+            notes.append("BLDG (build generation data group index)")
+        if _RE_CONNECT.search(text):
+            notes.append("CONNECT (add user catalog connection)")
+
+        summary = (
+            f"IEHPROGM: {len(events)} dataset mutations, {len(notes)} commands"
+            if events or notes
+            else "IEHPROGM with no recognised commands"
+        )
+        return ProgramAnalysis(
+            program="IEHPROGM",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=events,
+            notes=notes,
+            raw_control=text or None,
+        )

jcl_parser-1.3.0/jclparser/program_profiles/irxjcl.py

@@ -0,0 +1,58 @@
+"""Profile for ``IRXJCL`` — batch REXX exec runner.
+
+IRXJCL runs a single REXX exec named as the first token of ``PARM``; any
+remaining PARM text is passed as the exec's argument string. The exec
+source itself is read from ``SYSEXEC`` (a concatenation of PDS
+exec libraries) rather than SYSIN.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .base import ProgramAnalysis, ProgramProfile
+
+if TYPE_CHECKING:
+    from ..model import Step
+
+
+class IRXJCLProfile(ProgramProfile):
+    program_names = frozenset({"IRXJCL"})
+
+    def analyze(self, step: Step) -> ProgramAnalysis:
+        notes: list[str] = []
+        raw_parm = step.parameters.get("PARM")
+        # PARM=(subparm,...) is parsed into a list of strings; PARM=value or
+        # PARM='value text' stays a plain string. Normalise both to a string
+        # before splitting so a parenthesised PARM can't crash this profile.
+        if isinstance(raw_parm, list):
+            parm = " ".join(str(p) for p in raw_parm)
+        else:
+            parm = str(raw_parm) if raw_parm else ""
+        parts = parm.split(None, 1)
+        exec_name = parts[0].upper() if parts else ""
+        exec_args = parts[1] if len(parts) > 1 else ""
+
+        if exec_name:
+            notes.append(f"exec: {exec_name}")
+        if exec_args:
+            notes.append(f"args: {exec_args}")
+
+        sysexec = step.get_dd("SYSEXEC")
+        if sysexec and sysexec.dataset_name:
+            notes.append(f"SYSEXEC library: {sysexec.dataset_name}")
+
+        summary = (
+            f"IRXJCL: runs REXX exec {exec_name}"
+            if exec_name
+            else "IRXJCL with no exec name in PARM"
+        )
+        return ProgramAnalysis(
+            program="IRXJCL",
+            step_name=step.name or "",
+            summary=summary,
+            dataset_events=[],
+            notes=notes,
+            raw_control=parm or None,
+            invoked_programs=[exec_name] if exec_name else [],
+        )

{jcl_parser-1.2.1 → jcl_parser-1.3.0}/jclparser/program_profiles/registry.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from .base import ProgramProfile, ProgramAnalysis
+from .base import ProgramAnalysis, ProgramProfile
 
 if TYPE_CHECKING:
     from ..model import Job, Step
@@ -45,7 +45,7 @@ def get_profile(program_name: str | None) -> ProgramProfile | None:
     return None
 
 
-def analyze_step(step: "Step") -> ProgramAnalysis | None:
+def analyze_step(step: Step) -> ProgramAnalysis | None:
     """Run the matching profile (if any) against *step*."""
     profile = get_profile(step.program)
     if profile is None:
@@ -53,7 +53,7 @@ def analyze_step(step: "Step") -> ProgramAnalysis | None:
     return profile.analyze(step)
 
 
-def analyze_job(job: "Job") -> list[ProgramAnalysis]:
+def analyze_job(job: Job) -> list[ProgramAnalysis]:
     """Run all applicable profiles across every step in *job*."""
     from ..model import iter_execution_steps
 
@@ -71,30 +71,53 @@ def analyze_job(job: "Job") -> list[ProgramAnalysis]:
 
 
 def _register_builtins() -> None:
-    from .iefbr14 import IEFBR14Profile
-    from .idcams import IDCAMSProfile
-    from .iebgener import IEBGENERProfile, IEBCOPYProfile
-    from .sort import SortProfile
-    from .ikjeft01 import IKJEFT01Profile
+    from .adrdssu import ADRDSSUProfile
+    from .binder import BinderProfile
+    from .compilers import CompilerProfile
     from .db2_batch import DB2BatchProfile
     from .dfsrrc00 import DFSRRC00Profile
+    from .ftp import FTPProfile
+    from .icetool import ICETOOLProfile
+    from .idcams import IDCAMSProfile
+    from .iebdg import IEBDGProfile
+    from .iebgener import ICEGENERProfile, IEBCOPYProfile, IEBGENERProfile
+    from .iebptpch import IEBPTPCHProfile
+    from .iebupdte import IEBUPDTEProfile
+    from .iefbr14 import IEFBR14Profile
+    from .iehlist import IEHLISTProfile
+    from .iehprogm import IEHPROGMProfile
+    from .ikjeft01 import IKJEFT01Profile
+    from .irxjcl import IRXJCLProfile
+    from .sort import SortProfile
 
     register_profile(IEFBR14Profile())
     register_profile(IDCAMSProfile())
     register_profile(IEBGENERProfile())
     register_profile(IEBCOPYProfile())
+    register_profile(ICEGENERProfile())
     register_profile(SortProfile())
     register_profile(IKJEFT01Profile())
     register_profile(DB2BatchProfile())
     register_profile(DFSRRC00Profile())
+    register_profile(ICETOOLProfile())
+    register_profile(ADRDSSUProfile())
+    register_profile(IEHLISTProfile())
+    register_profile(IEHPROGMProfile())
+    register_profile(IEBUPDTEProfile())
+    register_profile(IEBPTPCHProfile())
+    register_profile(IEBDGProfile())
+    register_profile(BinderProfile())
+    register_profile(CompilerProfile())
+    register_profile(IRXJCLProfile())
+    register_profile(FTPProfile())
 
 
 _register_builtins()
 
 
 __all__ = [
-    "register_profile",
-    "get_profile",
-    "analyze_step",
     "analyze_job",
+    "analyze_step",
+    "get_profile",
+    "register_profile",
 ]

{jcl_parser-1.2.1 → jcl_parser-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "jcl-parser"
-version = "1.2.1"
+version = "1.3.0"
 description = "Parse IBM JCL (Job Control Language) scripts into Python objects"
 authors = [
     {name = "JCL Parser Team", email = "team@jclparser.dev"}