The following example shows the
PL/I program
that performs the tasks in
Handling a divide-by-zero condition in C, C++, COBOL, or PL/I.
*Process macro;
/* Module/File Name: IBMHDLR */
/****************************************************/
/* */
/* EXCOND .-> DIVZERO */
/* - register handler | - force a divide-by-0 */
/* - call DIVZERO --' */
/* ==> "resume point" */
/* - unregister handler */
/* USRHDLR: */
/* - if divide-by-zero then */
/* - move resume cursor */
/* - resume at "resume" */
/* point */
/* */
/****************************************************/
Excond :Proc Options(Main);
/**************************************************/
/* Important elements are found in these includes */
/* - feedback declaration */
/* - fbcheck macro call */
/* - condition tokens such as CEE000 */
/* - entry declarations such as ceehdlr */
/**************************************************/
%include ceeibmct;
%include ceeibmaw;
dcl Usrhdlr external entry;
dcl 1 fback feedback;
dcl divisor fixed bin(31);
dcl token fixed bin(31);
/*********************************************/
/* Register a user-written condition handler */
/*********************************************/
token = 97;
Call ceehdlr(Usrhdlr, token, fback);
If fbcheck (fback, cee000) then
display ('MAIN: registered USRHDLR');
else
do;
display ('CEEHDLR failed with message number ' ||
fback.MsgNo);
stop;
end;
/*********************************************/
/* Call DIVZERO to divide by zero */
/* and drive USRHDLR */
/*********************************************/
divisor = 0;
call divzero (divisor);
display ('MAIN: resumption after DIVZERO');
/*********************************************/
/* Unregister the user condition handler */
/*********************************************/
Call ceehdlu (Usrhdlr, fback);
If fbcheck (fback, cee000) then
display ('MAIN: unregistered USRHDLR');
else
do;
display ('CEEHDLU failed with message number ' ||
fback.MsgNo);
stop;
end;
/*********************************************/
/* Subroutine that simply raises ZERODIVIDE */
/*********************************************/
divzero: proc (arg);
dcl arg fixed bin(31);
display(' DIVZERO: starting.');
arg = 1 / arg;
display(' DIVZERO: Returning to its caller');
end divzero;
end Excond;
The following example is the usrhdlr program (PL/I) to handle divide-by-zero
conditions.
*Process macro;
/* Module/File Name: IBMMRCR */
/****************************************************/
/* */
/* Usrhdlr - the user handler routine. */
/* Handle DIVIDE-BY-ZERO conditions, */
/* percolate all others. */
/* */
/****************************************************/
Usrhdlr: Proc (@condtok, @token, @result, @newcond)
options(byvalue);
%include ceeibmct;
%include ceeibmaw;
/* Parameters */
dcl @condtok pointer;
dcl @token pointer;
dcl @result pointer;
dcl @newcond pointer;
dcl 1 condtok based(@condtok) feedback;
dcl token fixed bin(31) based(@token);
dcl result fixed bin(31) based(@result);
dcl 1 newcond based(@newcond) feedback;
dcl 1 fback feedback;
dcl move_type fixed bin(31);
dcl resume fixed bin(31) static initial(10);
dcl percolate fixed bin(31) static initial(20);
dcl promote fixed bin(31) static initial(30);
dcl promote_sf fixed bin(31) static initial(31);
display ('>>> USRHDLR: Entered user handler');
display ('>>> USRHDLR: passed token value is ' ||
token);
/* Check if this is the divide-by-zero token */
if fbcheck (condtok, cee349) then
do;
move_type = 0;
call ceemrcr (move_type, fback);
If fbcheck (fback, cee000) then
do;
result = resume;
display ('>>> USRHDLR: Resuming execution');
end;
else
do;
display
('CEEMRCR failed with message number ' ||
fback.MsgNo);
stop;
end;
end;
else /* something besides div-zero token */
do;
result = percolate;
display ('>>> USRHDLR: Percolating it');
end;
end Usrhdlr;