If a command sends its error message to the previous program, that program will be QCMDEXC. QCMDEXC will return an error indication to the calling RPG program, but if the RPG program wants any details about the error, those could be hard to get.

Since QCMDEXC can’t return any values from the command back to the calling program, my original suggestion - to call the command processing program directly from the RPG, so that error information can be passed back - is a sound proposition, when you are able to add a return code parameter to the command definition and the processing CL.

But if you can’t do that, as in the example you give of an emailing command, the best solution is to write a ‘wrapper’ CL program which can be called directly from your RPG program.

The wrapper program will have a return code, as previously described, to tell the RPG program whether an error ocurred, with some level of detail. It will also accept the parameters that the command requires. You can use the return code on the CALL to tell the wrapper whether you want to prompt the command or not - the parameter may be either blank or ‘*PROMPT’.

The wrapper would then execute the command, with or without prompting. The command processing program will send its error messages to the previous program, which will be the wrapper program, which can then receive the messages and set the return code before returning back to the RPG.

If your RPG program is a screen program, the wrapper could optionally resend the error messages to ITS previous program, which is the RPG program. If the program message queue specified in the screen message subfile is the same name as the program, then messages sent to it will appear in the message subfile when the screen is redisplayed.

Sloopy

CMD PROMPT(’Email an AS/400 Spool File’)
PARM KWD(ADDRESS) TYPE(*CHAR) LEN(80) MIN(1) +
CASE(*MIXED) PROMPT(’Email address’)
PARM KWD(ADDR1CC) TYPE(*CHAR) LEN(80) +
CASE(*MIXED) PROMPT(’Cc’)
PARM KWD(ADDR2CC) TYPE(*CHAR) LEN(80) +
CASE(*MIXED) PROMPT(’Cc’)
PARM KWD(ADDR3CC) TYPE(*CHAR) LEN(80) +
CASE(*MIXED) PROMPT(’Cc’)
PARM KWD(ADDR4CC) TYPE(*CHAR) LEN(80) +
CASE(*MIXED) PROMPT(’Cc’)
PARM KWD(FILE) TYPE(*NAME) MIN(1) MAX(1) +
PROMPT(’Spool file’)
PARM KWD(JOB) TYPE(JOB) DFT(*) SNGVAL((* ‘ ‘)) +
MAX(1) PROMPT(’Job’)
PARM KWD(SPLNBR) TYPE(*CHAR) LEN(5) DFT(*LAST) +
SPCVAL((*LAST) (*ONLY)) MIN(0) +
CHOICE(’1-9999, *LAST’) PROMPT(’Spooled +
file number’)
PARM KWD(DOC) TYPE(*CHAR) LEN(12) DFT(*DFT) +
SPCVAL((*DFT)) PROMPT(’Document name’)
PARM KWD(SUB) TYPE(*CHAR) LEN(44) SPCVAL((*DFT)) +
PROMPT(’Subject Line’)
PARM KWD(MSG) TYPE(*CHAR) LEN(256) DFT(*DFT) +
SPCVAL((*DFT)) PROMPT(’Message text’)
JOB: QUAL TYPE(*NAME) LEN(10)
QUAL TYPE(*NAME) LEN(10) CHOICE(*NONE) +
PROMPT(’User’)
QUAL TYPE(*CHAR) LEN(6) CHOICE(*NONE) +
PROMPT(’Number’)

CL Source:
PGM PARM(&ADDRESS &ADDR1CC &ADDR2CC &ADDR3CC +
&ADDR4CC &FILE &JOB_IN &SPLNBR &DOC &SUB +
&MSG)
/* Parameters… */
DCL VAR(&ADDRESS) TYPE(*CHAR) LEN(80)
DCL VAR(&ADDR1CC) TYPE(*CHAR) LEN(80)
DCL VAR(&ADDR2CC) TYPE(*CHAR) LEN(80)
DCL VAR(&ADDR3CC) TYPE(*CHAR) LEN(80)
DCL VAR(&ADDR4CC) TYPE(*CHAR) LEN(80)
DCL VAR(&FILE) TYPE(*CHAR) LEN(10)
DCL VAR(&JOB_IN) TYPE(*CHAR) LEN(26)
DCL VAR(&SPLNBR) TYPE(*CHAR) LEN(4)
DCL VAR(&DOC) TYPE(*CHAR) LEN(12)
DCL VAR(&SUB) TYPE(*CHAR) LEN(44)
DCL VAR(&MSG) TYPE(*CHAR) LEN(256)
/* Work fields… */
DCL VAR(&USER) TYPE(*CHAR) LEN(10)
DCL VAR(&JOB) TYPE(*CHAR) LEN(10)
DCL VAR(&NUMBER) TYPE(*CHAR) LEN(6)
DCL VAR(&UTLLIB) TYPE(*CHAR) LEN(10) +
VALUE(’WDISTLIB’)
DCL VAR(&RMVLIB) TYPE(*CHAR) LEN(1) VALUE(’1′)
DCL VAR(&FLR) TYPE(*CHAR) LEN(80) VALUE(’TEMP’)
DCL VAR(&LF) TYPE(*CHAR) LEN(3) VALUE(X’0D0D0D’)
DCL VAR(&WORD) TYPE(*CHAR) LEN(30)

/* 0010 - Split out job details… */
CHGVAR VAR(&NUMBER) VALUE(%SST(&JOB_IN 21 6))
CHGVAR VAR(&USER) VALUE(%SST(&JOB_IN 11 10))
CHGVAR VAR(&JOB) VALUE(%SST(&JOB_IN 01 10))

/* 0030 - Copy the spool file from either the qualified or current job… */
IF COND(&JOB_IN *EQ ‘ ‘) THEN(DO)
RTVJOBA JOB(&JOB) USER(&USER) NBR(&NUMBER)
ENDDO

/* 0100 - Build the stream file to be sent… */
IF COND(&DOC *EQ ‘*DFT’) THEN(DO)
CHGVAR VAR(&DOC) VALUE(’SP’ *CAT &NUMBER *CAT ‘.PDF’)
ENDDO

/* 0110 - If a default message is required then set it… */
IF COND(&MSG *EQ ‘*DFT’) THEN(DO)
CHGVAR VAR(&MSG) VALUE(’Spoolfile ‘ *CAT &FILE +
*TCAT ‘ from job ‘ *CAT &JOB *TCAT ‘/’ +
*CAT &USER *TCAT ‘/’ *CAT &NUMBER *CAT ‘ +
for your review.’)
ENDDO

CHGVAR VAR(&MSG) VALUE(&MSG *TCAT &LF)

/* 0120 - Convert Spooled File to PDF Document */
CVT2CMD FROMFILE(&FILE) TOSTMF(&DOC) +
TODIR(’qdlstemp’) +
JOB(&NUMBER/&USER/&JOB) SPLNBR(&SPLNBR) +
TOFMT(*PDF) STMFOPT(*REPLACE) +
TITLE(’ESPLF PDF’)
/* MONMSG MSGID(CPF3482) EXEC(SNDPGMMSG MSG(’File +
cannot be sent because it is Open’) +
TOUSR(&USER)) */

/* 0200 - Email the document to the email address… */
IF COND(&SUB *NE ‘ ‘) THEN(DO)
CHGDOCD DOC(&DOC) FLR(&FLR) DOCD(&SUB)
ENDDO
SNDDST TYPE(*DOC) TOINTNET((&ADDRESS) (&ADDR1CC +
*CC) (&ADDR2CC *CC) (&ADDR3CC *CC) +
(&ADDR4CC *CC)) DSTD(’Email of Spool +
File’) MSG(&MSG) DOC(&DOC) FLR(&FLR)
/* MONMSG MSGID(CPF901A) EXEC(SNDPGMMSG MSG(’Send +
Distribution Request Failed’)) */

/* 9010 - Clear down the work files and documents… */

DLTDLO DLO(&DOC) FLR(&FLR)
/* MONMSG MSGID(CPF8A16) EXEC(SNDPGMMSG MSG(’Document +
Object Deletion Failed’)) */

/* 9100 - Remove the utility library from the library list… */

IF COND(&RMVLIB *EQ ‘1′) THEN(DO)
RMVLIBLE LIB(&UTLLIB)
MONMSG MSGID(CPF0000)
ENDDO

/* 9900 - Finally exit the program… */

ENDIT: ENDPGM


In our programs, we always include a 7-character return code in our parameter lists for calls. Seven characters allows us to send a word of up to seven sensible characters OR a proper message ID, which the calling program can send.

If a call returns a blank return code, the caller can assume that the function completed correctly.

If a CL program is used as a command processing program, it can still be called directly from a HLL program. To distinguish between the uses, the command definition is created with its first parameter a 7-character constant with the value ‘*CMD’. The CL program recognises this, and will handle errors and return them as escape messages, to be handled by whatever used the command.

If a HLL program calls the CL, it does so directly and not through the command. In that case, the first parameter is the 7-character return code, and it will NOT contain the value ‘*CMD’. The CL now knows that it is being called directly and will not generate escape messages, but will instead pass a value back through the return code to the calling program.

The additional advantage of this is that all the error checking is done in the CL, where it is easiest; there is no complicated processing in any of the programs thay may call it.

Regards,

Sloopy