1. In the assembly procedure ASMAC (Figure 1), you might want to suppress the object module to SYSPUNCH and respecify the UNIT= and SPACE= parameters of data set SYSUT1. In this case, the following statements are required:

   //stepname     EXEC   PROC=ASMAC,
   //                    PARM=NODECK
   //SYSUT1       DD     UNIT=3390,
   //                    SPACE=(4096,(300,40))
   //SYSIN        DD     *
   ⋮
   assembler source statements
   ⋮
   /*

2. In procedure ASMACLG (Figure 1), you might want to suppress the assembler listing, and add the COND= parameter to the EXEC statement that invokes the binder. In this case, the EXEC statement in the input stream are:

   //stepname    EXEC   PROC=ASMACLG,
   //                   PARM.C=(NOLIST,OBJECT),
   //                   COND.L=(8,LT,stepname.C)

   For this run of procedure ASMACLG, no assembler listing is produced, and running of the binder job step //L is suppressed if the return code issued by the assembler (step C) is greater than 8.

   When you override the PARM field in a procedure, the whole PARM field is overridden. Thus, in this example, overriding the LIST parameter effectively deletes PARM=(OBJECT,NODECK). PARM=(OBJECT,NODECK) must be repeated in the override statement; otherwise, the assembler default values are used.

3. The following example shows how to use the procedure ASMACL (Figure 1) to:

    1 

   Read input from a nonlabeled 9-track tape in unit 282 that has a standard blocking factor of 10.

    2 

   Put the output listing on a tape labeled TAPE10, with a data set name of PROG1 and a blocking factor of 5.

    3 

   Block the SYSLIN output of the assembler and use it as input to the binder with a blocking factor of 10.

    4 

   Link the module only if there are no errors in the assembly (COND=0).

    5 

   Link onto a previously allocated and cataloged data set USER.LIBRARY with a member name of PROG.

   //jobname      JOB
   //stepname     EXEC   PROC=ASMACL,
   //                    COND.L=(0,NE,stepname.C)                         4 
   //C.SYSPRINT   DD     DSNAME=PROG1,UNIT=TAPE,                          2 
   //                    VOLUME=SER=TAPE10,DCB=(BLKSIZE=665)
   //C.SYSLIN     DD     DCB=(BLKSIZE=800)                                3 
   //C.SYSIN      DD     UNIT=282,LABEL=(,NL),                            1 
   //                    DCB=(RECFM=FBS,BLKSIZE=800)
   //L.SYSLIN     DD     DCB=stepname.C.SYSLIN                            3 
   //L.SYSLMOD    DD     DSNAME=USER.LIBRARY(PROG),DISP=OLD               5 
   /*

   The order of appearance of overriding ddnames for job step C corresponds to the order of ddnames in the procedure; that is, SYSPRINT precedes SYSLIN within step C. The ddname C.SYSIN was placed last because SYSIN does not occur at all within step C. These points are covered in the applicable JCL Reference.

4. The following example shows assembly of two programs, link of the two object modules produced by the assemblies into one program module, and running the generated program. The input stream appears as follows:

   //stepname1      EXEC    PROC=ASMAC,PARM=OBJECT
   //SYSIN          DD      *
   ⋮
   assembler source statements for program 1
   ⋮
   /*
   //stepname2      EXEC    PROC=ASMACLG
   //C.SYSIN        DD      *
   ⋮
   assembler source statements for program 2
   ⋮
   /*
   //L.SYSIN        DD      *
                    ENTRY PROG
   /*
   //G.ddname       DD      dd statements for G step

The applicable JCL Reference provides additional descriptions of overriding techniques.