SYSIN in Easytrieve

SYSIN as the Source Stream

Easytrieve compile jobs usually execute the Easytrieve processor and point SYSIN to the source stream. The processor reads statements such as PARM, FILE, JOB, IF, PRINT, REPORT, TITLE, and LINE. Broadcom’s beginner examples show source entered and run from a terminal or submitted as a text member. In batch JCL, SYSIN is how that text enters the compiler step.

The key idea is simple: SYSIN is read, not executed directly by JCL. JCL supplies the stream; Easytrieve interprets it as source or control data. If the wrong member is placed on SYSIN, the compiler faithfully compiles the wrong source. If the source is truncated, the compiler can only diagnose what it receives.

Inline SYSIN

Inline SYSIN is useful for small examples, tests, and tutorials. The JCL uses DD * or DD DATA and places the Easytrieve source directly after the DD statement. The input ends at the JCL delimiter, commonly /* for DD * input. This is easy to read in a small sample but awkward for large production programs because source changes require editing JCL.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//EZTRUN   EXEC PGM=EZTPA00
//STEPLIB  DD  DSN=DEV.EASYTRIEVE.CBAALOAD,DISP=SHR
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
FILE PERSNL FB(150 1800)
  EMPNAME  17  8  A
  EMPNO     9  5  N
  DEPT     98  3  N
 
JOB INPUT PERSNL
  PRINT PAY-RPT
 
REPORT PAY-RPT LINESIZE 80
  TITLE 01 'PERSONNEL REPORT'
  LINE 01 DEPT EMPNAME EMPNO
/*

Inline source is self-contained. That is its advantage. It is also easy to submit a slightly different source than the controlled library version. For training, inline SYSIN is excellent. For enterprise maintenance, source libraries and change management usually provide better auditability.

SYSIN from a Source Member

Production compile JCL often points SYSIN to a member in a source library. The dataset name identifies the PDS or PDSE. The member name in parentheses identifies the Easytrieve program. This pattern separates JCL from source and lets source management tools promote members through DEV, QA, and PROD libraries.

1
2
3
4
//EZTCOMP  EXEC PGM=EZTPA00
//STEPLIB  DD  DSN=QA.EASYTRIEVE.CBAALOAD,DISP=SHR
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  DSN=QA.EZT.SOURCE(PAYRPT),DISP=SHR

This example reads member PAYRPT from QA.EZT.SOURCE. If PAYRPT also exists in DEV or PROD, those versions are irrelevant unless the JCL points to them. When a developer says “I changed the program,” verify that the SYSIN DD in the submitted job reads the changed library and member.

SYSIN as Control Cards

SYSIN can also provide control statements rather than full Easytrieve source. A runtime job might use SYSIN for parameters, date ranges, report selection values, or utility control cards. Whether Easytrieve reads those values depends on the program design and site conventions. Some shops prefer a separate DD name for business parameters to avoid confusing compile SYSIN with runtime control input.

1
2
3
4
5
6
7
8
9
//RUNRPT   EXEC PGM=SALESRPT
//STEPLIB  DD  DSN=PROD.APP.LOADLIB,DISP=SHR
//SALESIN  DD  DSN=PROD.SALES.DAILY,DISP=SHR
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
REGION=WEST
START-DATE=2026-07-01
END-DATE=2026-07-31
/*

This kind of SYSIN is not automatically meaningful to every Easytrieve program. The program must be written to read and interpret the control records. If no code reads SYSIN at runtime, these lines do nothing useful even though the JCL is valid.

PARM Statements and SYSIN

Easytrieve examples often include PARM statements at the beginning of the source stream. PARM controls how the processor behaves: syntax check, compile, link, compatibility, and other options depending on release and site configuration. Because PARM is part of the source/control stream, it can be supplied through inline SYSIN or through a source member.

1
2
3
4
5
6
7
8
9
PARM SYNTAX
FILE ACCTIN FB(200 2000)
  ACCT-NO     1  10  N
  ACCT-TYPE  11   2  A
 
JOB INPUT ACCTIN
  IF ACCT-TYPE = 'SV'
    PRINT SAVINGS-RPT
  END-IF

PARM SYNTAX asks for a syntax-focused run. If the job unexpectedly creates a load module or runs the report, check whether the source member contains a different PARM, whether a procedure injects options elsewhere, or whether the options table supplies defaults not visible in the source member.

Inline vs Member SYSIN

How SYSPRINT Proves SYSIN

When in doubt, read the compile listing on SYSPRINT. It shows the source lines the compiler actually processed. That evidence beats assumptions about which library, member, or procedure symbol “should” have been used. If the listing lacks a change you expected, the job did not read your changed source. If the listing contains generated source or expanded macros, it can also reveal how SYSIN and macro libraries combined.

Common SYSIN Mistakes

• Submitting inline test source while believing a controlled source member was compiled.
• Pointing SYSIN to DEV when the job should read QA or production source.
• Misspelling a member name and receiving a JCL or allocation error before compile.
• Forgetting the inline delimiter and accidentally treating following JCL as input text.
• Changing source after the compile but running an old load module in a separate runtime step.
• Using SYSIN for runtime parameters when the program expects a different DD name.

SYSIN and Security

Source libraries can be protected just like load and business libraries. A developer may read DEV source but not production source. A scheduler ID may read production source for compile but not update it. If SYSIN points to a protected dataset and the executing ID lacks access, the job fails before Easytrieve can process the program. The fix is access or procedure correction, not a source syntax edit.

Troubleshooting Checklist

1. Find the resolved SYSIN DD in the submitted JCL or procedure expansion.
2. Identify whether SYSIN is inline, a member, a sequential dataset, or a temporary dataset.
3. Verify dataset name, member name, DISP, catalog status, and security access.
4. Read the SYSPRINT listing to confirm the exact source lines processed.
5. Check whether procedure symbols changed the library or member at submission time.
6. For runtime control cards, confirm the program actually reads SYSIN and expects that format.

Explain It Like I'm Five

SYSIN is the paper you hand to Easytrieve before it starts working. Sometimes the paper is taped inside the job itself. Sometimes it is pulled from a folder with a member name on it. If you hand Easytrieve the wrong paper, it follows the wrong instructions. To check what paper it received, read the notes it printed on SYSPRINT.

Exercises

1. Write one compile JCL that uses inline SYSIN and one that reads a source member.
2. Explain why changing a source member does not automatically update an already linked runtime program.
3. Find the inline delimiter in a DD * example and describe what happens if it is omitted.
4. List three ways procedure symbols can make SYSIN read a different source than expected.
5. Describe how SYSPRINT can prove which SYSIN input was compiled.