CBT Tape - File 183 - EXECUTE is a REXX exec

/*************************************************************** REXX */
/*                                                                    */
/* MODULE NAME = EXECUTE                                              */
/*                                                                    */
/* DESCRIPTIVE NAME = Execute an in-stream CLIST or REXX EXEC         */
/*                                                                    */
/* STATUS = R204                                                      */
/*                                                                    */
/* FUNCTION = EXECUTE is a REXX EXEC which allows you to execute an   */
/*            in-stream CLIST or a REXX EXEC in a TSO batch TMP step. */
/*            Using EXECUTE, you can work around a limitation of      */
/*            standard TSO/E which can only execute a CLIST or a REXX */
/*            EXEC stored in a PDS member or a sequential data set.   */
/*                                                                    */
/*            EXECUTE can also be invoked as an EDIT macro to         */
/*            execute the current data set as a CLIST or REXX exec.   */
/*            The user can select a line or range of lines to         */
/*            execute by specifying the C, Cn or CC/CC line commands. */
/*                                                                    */
/* AUTHOR   =  Gilbert Saint-Flour              */
/*             http://gsf-soft.com/Freeware/                          */
/*                                                                    */
/* DEPENDENCIES = TSO/E V2                                            */
/*                                                                    */
/* SYNTAX = see below                                                 */
/*                                                                    */
/*          EXECUTE CLIST|EXEC                                        */
/*                  TRACE|NOTRACE                                     */
/*                  ISPF|ISPSTART                                     */
/*                                                                    */
/*     Default:     CLIST,NOTRACE                                     */
/*                                                                    */
/*     Sample JCL with PARM and a CLIST :                             */
/*                                                                    */
/*        //CLIST EXEC PGM=IKJEFT01,PARM='%EXECUTE'                   */
/*        //SYSPROC DD DSN=,DISP=SHR  */
/*        //SYSTSPRT DD SYSOUT=*                                      */
/*        //SYSTSIN DD *                                              */
/*        WRITE In-line CLIST executed by &SYSUID                     */
/*        /*                                                       */ */
/*                                                                    */
/*     Sample JCL with in-line EXECUTE REXX command :                 */
/*                                                                    */
/*        //EXEC EXEC PGM=IKJEFT01                                    */
/*        //SYSEXEC DD DSN=,DISP=SHR  */
/*        //SYSTSPRT DD SYSOUT=*                                      */
/*        //SYSTSIN DD *                                              */
/*        %EXECUTE EXEC                                               */
/*        SAY "In-line EXEC executed by" USERID()                     */
/*        /*                                                       */ */
/*                                                                    */
/*     Sample JCL with PARM and ISPF option :                         */
/*                                                                    */
/*        //ISPF EXEC PGM=IKJEFT01,PARM='%EXECUTE EXEC ISPF'          */
/*        //SYSEXEC DD DSN=,DISP=SHR               */
/*        //SYSTSPRT DD SYSOUT=*                                      */
/*        //SYSTSIN DD *                                              */
/*        SAY "In-line EXEC executed by" USERID() in ISPF             */
/*        SAY "That's it, it's done !"                                */
/*        /*                                                       */ */
/*        //ISPMLIB DD DSN=ISP.SISPMENU,DISP=SHR                      */
/*        //ISPTLIB DD DSN=ISP.SISPTENU,DISP=SHR                      */
/*        //ISPPROF DD UNIT=VIO,SPACE=(TRK,(1,1,1)),RECFM=FB,LRECL=80 */
/*        //ISPPLIB DD DSN=*.ISPPROF,DISP=OLD,VOL=REF=*.ISPPROF       */
/*        //ISPSLIB DD DSN=*.ISPPROF,DISP=OLD,VOL=REF=*.ISPPROF       */
/*        //ISPLOG  DD SYSOUT=*,RECFM=FB,LRECL=121,DSN=&&ISPLOG       */
/*                                                                    */
/*      BATCH mode - execute an in-line CLIST which uses REXXTRY      */
/*                   to execute an in-line REXX exec                  */
/*                                                                    */
/*        //CLISTRX EXEC PGM=IKJEFT01                                 */
/*        //STEPLIB  DD DSN=CBTTAPE.FILE183.LOAD,DISP=SHR   REXXTRY   */
/*        //SYSPROC  DD DSN=CBTTAPE.FILE183.PDS,DISP=SHR    EXECUTE   */
/*        //SYSTSPRT DD SYSOUT=*                                      */
/*        //SYSTSIN  DD *                                             */
/*        %EXECUTE CLIST                                              */
/*          /* The CLIST starts here */                               */
/*        CONTROL LIST CONLIST                             /*CLIST*/  */
/*        WRITE Start of the CLIST                         /*CLIST*/  */
/*        REXXTRY A=1;                                     /*REXX*/ + */
/*                B=2;                                     /*REXX*/ + */
/*                UID=USERID();                            /*REXX*/ + */
/*                RETURN(A+B UID)                          /*REXX*/   */
/*        WRITE LASTCC=&LASTCC RESULT='&RESULT'            /*CLIST*/  */
/*        EXIT CODE(&LASTCC)                               /*CLIST*/  */
/*                                                                    */
/* OPERATION = see below                                              */
/*                                                                    */
/*        EXECUTE can be executed from SYSPROC or SYSEXEC.            */
/*                                                                    */
/*        EXECUTE creates a temporary data set, copies the in-stream  */
/*        commands into it, then issues the TSO EXEC command.         */
/*        EXECUTE processes the in-line commands as a CLIST except    */
/*        when (1) it is invoked with the EXEC key-word or (2) the    */
/*        REXX word appears in a comment on the first line.           */
/*                                                                    */
/* CHANGES = see below                                                */
/*                                                                    */
/* 200 New packaging for the CBT tape                                 */
/* 201 Can be invoked as an EDIT macro                                */
/* 202 Add TRACE option                                               */
/* 203 Add ISPF option                                                */
/* 204 Change PULL to PARSE PULL to prevent conversion to uppercase   */
/*                                                                    */
/**********************************************************************/