*PROCESS MAR(2,72,1); /* THIS PROGRAM PROVIDES AN EXAMPLE OF HOW THE CLI2 INTER- */ /* FACE CAN BE USED TO PERFORM THE FOLLOWING FUNCTIONS: */ /* */ /* -- CALL ANOTHER PROGRAM TO DROP/CREATE A TABLE. AN */ /* INITIALIZED DBCAREA CONTAINING THE LOGON STRING */ /* IS PASSED TO THE CALLED PROGRAM. */ /* */ /* -- CONNECT MULTIPLE SESSIONS. */ /* */ /* -- CALL “DBCHWAT” TO WAIT ON AVAILABLE REQUEST (NO */ /* IMPLICIT WAITS BY CLI2). */ /* */ /* -- TERMINATE A REQUEST AND INITIATE ANOTHER REQUEST */ /* AFTER RESPONSE PARCELS HAVE BEEN FETCHED. */ /* */ /* -- THE INITIATED REQUEST IS A MULTI-STATEMENT */ /* REQUEST CONTAINING FIVE INSERT AND FIVE UPDATES */ /* (ONE TRANSACTION). */ /* */ /* -- DISCONNECT SESSIONS WHEN ALL TRANSACTIONS HAVE */ /* BEEN PROCESSED. */ /* */ /* NOTE: THIS VERSION OF THE SAMPLE PROGRAM IS DESIGNED */ /* TO EXECUTE AS AN IMS MPP CONVERSATIONAL PROGRAM. */ /* */ /* AUTHOR: J. LAHOOD */ /* */ 1CLI2MPI: PROC(PCBPTR) OPTIONS(MAIN); DCL PLITDLI ENTRY EXTERNAL; DCL PLIXOPT CHAR(24) VAR INIT(’ISA(4K),NOSTAE,NOSPIE’) STATIC EXTERNAL; DCL PCBPTR POINTER, 1 IOPCB BASED(PCBPTR), 2 LTERM CHAR(8), 2 FILLER CHAR(2), 2 IOPCB_STATUS CHAR(2), 2 PREFIX CHAR(12); DCL (STG,SUBSTR,ADDR) BUILTIN; /* */ /*----------------------------------------------------------*/ /* * DATA DEFINITIONS */ /* * */ /* ---------------------------------------------------------*/ /* DL/I CALL FUNCTIONS */ DCL GU_FUNC CHAR(4) STATIC INIT(’GU ’), GN_FUNC CHAR(4) STATIC INIT(’GN ’), ISRT_FUNC CHAR(4) STATIC INIT(’ISRT’); /* */ /* PL/I PARAMETER COUNTER */ /* */ DCL THREE FIXED BIN(31) INIT(3); /* */ /* CLI2 SUBROUTINES AND CLICTAB (CREATES TABLE) */ /* */ DCL (DBCHINI, DBCHCL, DBCHWAT, CLI2CTB, DBCHCLN) ENTRY EXTERNAL OPTIONS(ASSEMBLER, INTER); /* CONSTANTS */ /* TYPE OF FUNCTION -- USED IN MESSAGES */ DCL TYPE_FUNC CHAR(8) STATIC, /* NUMBER OF SESSIONS TO BE CONNECTED */ /* */ /* */ NUMLOG FIXED BIN(15) STATIC INIT(3), /* */ /* CURRENT NUMBER OF SESSIONS. */ /* */ NUMBER_OF_SESSIONS FIXED BIN(15) STATIC INIT(0), /* */ /* NUMBER OF INSERT/UPDATE TRANSACTIONS PER ITERATION */ /* */ MAXTRANS FIXED BIN(31) STATIC INIT(10), /* */ /* TRANSACTION COUNTER */ /* */ TRANS_COUNT FIXED BIN(31) STATIC INIT(0), /* */ /* MAXIMUM RESPONSE BUFFER SIZE FOR FETCHING */ /* */ RESPBUF_SIZE FIXED BIN(31) STATIC INIT(4096), /* */ /* WORD USED IN MESSAGE (SINGULAR/PLURAL FORM). * /* */ PASS_TYPE CHAR(7) STATIC, /* */ /* LOGON STRING -- FROM IMS INPUT MESSAGE (FIRST PASS). */ /* LOGON_STRING CHAR(4) STATIC INIT(’0/LAHOOD,J’) */ /* */ LOGON_STRING CHAR(40) STATIC, /* */ /* LENGTH OF LOGON STRING -- OBTAINED VIA PL/I ’STG’ */ /* FUNCTION. */ /* MY_LOGON_LEN FIXED BIN(31) STATIC INIT(30), /* */ /* */ /* RUNNING COUNT OF LOGGED ON SESSIONS */ /* */ LOGID FIXED BIN(15) STATIC INIT(1), /* */ /* SESSION ID RETURNED BY DBCHWAT */ /* */ WAIT_SESSID FIXED BIN(31) STATIC INIT(0), /* */ /* INDEX USED TO ACCESS TOKEN_ARRAY */ /* */ TOKEN_INDEX FIXED BIN(31) STATIC INIT(0), /* */ /* TOKEN RETURNED BY DBCHWAT */ /* */ WAIT_TOKEN FIXED BIN(31) STATIC INIT(0), /* */ /* CLI CODES */ /* */ BUSY_CODE FIXED BIN(31) STATIC INIT(150), EOF_CODE FIXED BIN(31) STATIC INIT(33), CRASH_CODE FIXED BIN(31) STATIC INIT(286); /* */ /* SCRATCH PAD AREA LAYOUT */ /* */ DCL 1 SPA STATIC, 2 LL FIXED BIN(31), 2 ZZ FIXED BIN(31), 2 SPA_TRANCODE CHAR(8), 2 PASS_COUNT FIXED BIN(15), 2 NEXT_DATA_VALUES, 03 DATA1 FIXED BIN(31), 03 DATA2 FIXED BIN(31), 03 DATA3 FIXED BIN(31), 03 DATA4 FIXED BIN(31), 03 DATA5 FIXED BIN(31), 2 LOGON_STRING_SPA CHAR(40), 2 FILLER CHAR(2048); /* */ /* */ DCL INSERT_MORE CHAR(1) STATIC INIT(’Y’), INSERT_OK CHAR(4) STATIC INIT(’YES ’); /* */ /* INPUT/OUTPUT AREAS */ /* */ DCL 1 INPUT_MESSAGE STATIC, 2 IN_LL1 FIXED BIN(31), 2 IN_ZZ1 FIXED BIN(15), 2 IN_TEXT CHAR(30), 2 FILLER CHAR(132), 1 OUTPUT_MESSAGE STATIC, 2 OUT_LL1 FIXED BIN(31) INIT(79), 2 OUT_ZZ FIXED BIN(15) INIT(’0’B), 2 OUT_TEXT CHAR(80); /* */ /* DBC/SQL REQUESTS TO BE EXECUTED */ /* */ DCL 1 MULTI_STMT_REQS STATIC, 2 L1 CHAR(50) INIT (’USING V1 (INTEGER),V2 (INTEGER),V3 (INTEGER), ’), 2 L2 CHAR(50) INIT (’ V4 (INTEGER),V5 (INTEGER) ’), 2 L3 CHAR(50) INIT (’INSERT INTO MYTABLE2 (F1) VALUES(:V1); ’), 2 L4 CHAR(50) INIT (’INSERT INTO MYTABLE2 (F1) VALUES(:V2); ’), 2 L5 CHAR(50) INIT (’INSERT INTO MYTABLE2 (F1) VALUES(:V3); ’), 2 L6 CHAR(50) INIT (’INSERT INTO MYTABLE2 (F1) VALUES(:V4); ’), 2 L7 CHAR(50) INIT (’INSERT INTO MYTABLE2 (F1) VALUES(:V5); ’), 2 L8 CHAR(50) INIT (’UPDATE MYTABLE2 SET F2 = F1+1 WHERE F1=:V1; ’), 2 L9 CHAR(50) INIT (’UPDATE MYTABLE2 SET F2 = F1+1 WHERE F1=:V2; ’), 2 L10 CHAR(50) INIT (’UPDATE MYTABLE2 SET F2 = F1+1 WHERE F1=:V3; ’), 2 L11 CHAR(50) INIT (’UPDATE MYTABLE2 SET F2 = F1+1 WHERE F1=:V4; ’), 2 L12 CHAR(50) INIT (’UPDATE MYTABLE2 SET F2 = F1+1 WHERE F1=:V5; ’), 1 MULTI_STMT_REQ DEF MULTI_STMT_REQS, 2 EACH_REQUEST(12) CHAR(50), MULT_STMT_LEN FIXED BIN(31) STATIC INIT(600), 1 DATA_FOR_INS_UPD STATIC, 2 DATA1 FIXED BIN(31) INIT(1), 2 DATA2 FIXED BIN(31) INIT(2), 2 DATA3 FIXED BIN(31) INIT(3), 2 DATA4 FIXED BIN(31) INIT(4), 2 DATA5 FIXED BIN(31) INIT(5), 1 DATA_LEN FIXED BIN(31) STATIC INIT(20); %INCLUDE DBCAREAP; %INCLUDE CLIPARMP; /* */ /* */ DCL 1 TOKEN_ARRAY(20), 2 SESSID FIXED BIN(31), 2 REQID FIXED BIN(31), 2 TOKEN FIXED BIN(31), 2 TDPSESS FIXED BIN(31), ‘ 2 TDPREQID FIXED BIN(31), 2 LAST_FUNCTION CHAR(8); DCL 1 MSG_INFO, 2 MSG_INFO_FUNC FIXED BIN(31), 2 MSG_INFO_RC FIXED BIN(31), 2 MSG_INFO_CLI_MSG CHAR(76), 2 MSG_INFO_FECODE FIXED BIN(31), 2 MSG_INFO_LEN FIXED BIN(15), 2 MSG_INFO_TEXT CHAR(256); 1/* */ /* START PROCESSING -- MAIN LOOP */ /* */ /* */ CALL READ_SPA; DO UNTIL(IOPCB_STATUS = ’QC’); CALL PROCESS_MSG; END; /* */ /* */ PROCESS_MSG: PROC; IF SPA.PASS_COUNT = 0 THEN CALL READ1; ELSE CALL READ2; IF INSERT_MORE = ’Y’ THEN CALL INSERT_ROWS; ELSE DO; OUT_TEXT = SPA_TRANCODE || ’ TRANSACTION COMPLETED. USE BTEQ TO CHECK RESULTS.’; INSERT_OK = ’NO ’; SPA_TRANCODE = ’ ’; CALL ISRT_MSG; END; IF INSERT_OK = ’YES ’ THEN DO; PASS_COUNT = PASS_COUNT + 1 ; CALL SET_PASS_TYPE; OUT_TEXT = PASS_COUNT || PASS_TYPE || ’ COMPLETED’ || ’ ENTER YES TO CONTINUE OR NO TO END CONVERSATION.’; CALL ISRT_MSG; END; CALL ISRT_SPA; CALL READ_SPA; END PROCESS_MSG; /* */ /* */ READ_SPA: PROC; CALL PLITDLI(THREE,GU_FUNC,PCBPTR,SPA); IF (IOPCB_STATUS = ’ ’) | (IOPCB_STATUS = ’QC’) THEN; ELSE DO; TYPE_FUNC = ’GU_SPA’; CALL STATUS_ERROR; END; END READ_SPA; /* */ /* */ READ1: PROC; IN_TEXT = ’ ’; CALL PLITDLI(THREE,GN_FUNC,PCBPTR, INPUT_MESSAGE); IF IOPCB_STATUS = ’ ’ THEN DO; TYPE_FUNC = ’GN 1’; CALL STATUS_ERROR; END; ELSE DO; LOGON_STRING = IN_TEXT; LOGON_STRING_SPA = ’ ’; LOGON_STRING_SPA = IN_TEXT; INSERT_MORE = ’Y’; INSERT_OK = ’YES’; END; END READ1; /* */ /* */ READ2: PROC; CALL PLITDLI(THREE,GN_FUNC,PCBPTR,INPUT_MESSAGE); IF IOPCB_STATUS = ’ ’ THEN DO; TYPE_FUNC = ’GN 2’; CALL STATUS_ERROR; END; ELSE DO; LOGON_STRING = LOGON_STRING_SPA ; INSERT_MORE = SUBSTR(IN_TEXT,1,1); INSERT_OK = ’YES ’; END; END READ2; /* */ /* */ ISRT_SPA: PROC; CALL PLITDLI(THREE,ISRT_FUNC, PCBPTR, SPA); IF IOPCB_STATUS = ’ ’ THEN DO; TYPE_FUNC = ’ISRT_SPA’; CALL STATUS_ERROR; END; END ISRT_SPA; /* */ /* */ ISRT_MSG: PROC; CALL PLITDLI(THREE,ISRT_FUNC, PCBPTR,OUTPUT_MESSAGE); IF IOPCB_STATUS = ’ ’ THEN DO; TYPE_FUNC = ’ISRT_MSG’; CALL STATUS_ERROR; END; OUT_TEXT = ’ ’; END ISRT_MSG; /* */ /* */ STATUS_ERROR: PROC; OUT_TEXT = ’BAD IOPCB_STATUS -- FUNCTION = ’ || TYPE_FUNC || ’ STATUS = ’ || IOPCB_STATUS; CALL PLITDLI(THREE,ISRT_FUNC, PCBPTR,OUTPUT_MESSAGE); SPA_TRANCODE = ’ ’; CALL PLITDLI(THREE,ISRT_FUNC, PCBPTR, SPA); GO TO IMMEDIATE_IMS_RETURN; END STATUS_ERROR; /* */ /* */ SET_PASS_TYPE: PROC; IF PASS_COUNT = 1 THEN PASS_TYPE = ’ PASS’; ELSE PASS_TYPE = ’ PASSES’; END SET_PASS_TYPE; /* */ /* */ /* ************************************************************* */ INSERT_ROWS: PROC; ‘ CALL DBC_INIT; /* SET UP POINTER TO LOGON STRING */ DBCAREA.LOGON_PTR = ADDR(LOGON_STRING); /* SET UP LENGTH OF LOGON STRING */ DBCAREA.LOGON_LEN = STG(LOGON_STRING); /* ON FIRST PASS ONLY: */ /* CALL A PROGRAM TO DROP THEN CREATE THE TABLE “MYTABLE2". */ IF PASS_COUNT = 0 THEN DO; CALL CLI2CTB(DBCAREA, MSG_INFO); CALL CHECK_CALL; DATA_FOR_INS_UPD.DATA1 = 1; DATA_FOR_INS_UPD.DATA2 = 2; DATA_FOR_INS_UPD.DATA3 = 3; DATA_FOR_INS_UPD.DATA4 = 4; DATA_FOR_INS_UPD.DATA5 = 5; END; ELSE DATA_FOR_INS_UPD = SPA.NEXT_DATA_VALUES; CALL DBCAREA_SETUP; NUMBER_OF_SESSIONS = 0; TRANS_COUNT = 0; DO LOGID = 1 TO NUMLOG BY 1; CALL CLI_CONNECT; END; DO UNTIL(NUMBER_OF_SESSIONS = 0); CALL WAIT_FETCH_IRQ; END; SPA.NEXT_DATA_VALUES = DATA_FOR_INS_UPD; END INSERT_ROWS; /* */ /* */ CHECK_CALL: PROC; IF MSG_INFO_RC = 0 THEN DO; DBCAREA.FUNC = MSG_INFO_FUNC; CLI_RETURN_CD = MSG_INFO_RC; DBCAREA.MSG_TEXT = MSG_INFO_CLI_MSG; CALL DISP_ERROR; END; ELSE IF MSG_INFO_LEN = 0 THEN DO; OUT_TEXT = ’FAILURE PARCEL RECEIVED IN CALLED PROG.’ || ’ FAILURE CODE = ’ || MSG_INFO_FECODE ; CALL ISRT_MSG; OUT_TEXT = SUBSTR(MSG_INFO_TEXT,1,MSG_INFO_LEN); CALL END_TRANS; END; END CHECK_CALL; /* */ /* */ END_TRANS: PROC; CALL ISRT_MSG; SPA_TRANCODE = ’ ’; CALL ISRT_SPA; GO TO IMMEDIATE_IMS_RETURN; END END_TRANS; /* */ /* */ /* *********** WAIT FOR AVAILABLE REQUEST. ****/ /* *********** USE TOKEN FROM WAIT AS INDEX TO ****/ /* *********** OBTAIN SESSID AND REQID. ****/ /* *********** FETCH PARCELS -- ****/ /* *********** WHEN EOF,INITIATE INSERT REQUEST. ****/ WAIT_FETCH_IRQ: PROC; CLI_RETURN_CD = BUSY_CODE; /* ENTER AT LEAST ONCE */ DO UNTIL((CLI_RETURN_CD = BUSY_CODE) & (CLI_RETURN_CD = CRASH_CODE) ); CALL CLI_WAIT; END; TOKEN_INDEX = WAIT_TOKEN /* USE TOKEN FROM DBCHWAT */; DBCAREA.I_SESS_ID = SESSID(TOKEN_INDEX); DBCAREA.I_REQ_ID = REQID(TOKEN_INDEX) ; DO UNTIL((CLI_RETURN_CD = EOF_CODE) | (CLI_RETURN_CD = BUSY_CODE) | (CLI_RETURN_CD = CRASH_CODE)); CALL CLI_FETCH_PARCELS; END; IF (CLI_RETURN_CD = EOF_CODE) & (LAST_FUNCTION(TOKEN_INDEX) = ’LOGON’) THEN TDPSESS(TOKEN_INDEX) = DBCAREA.TDP_SESS_ID; IF CLI_RETURN_CD = EOF_CODE THEN DO; CALL CLI_END_REQUEST; IF TRANS_COUNT < MAXTRANS THEN CALL IRQ_CALL; ELSE DO; CALL CLI_DISCONNECT; NUMBER_OF_SESSIONS = NUMBER_OF_SESSIONS - 1; END; END; END WAIT_FETCH_IRQ; /* */ /* */ /* ****************************************************************/ /* ***************** WAIT FOR AVAILABLE REQUEST */ CLI_WAIT: PROC; /* WAIT FOR POSTED REQUEST */ CALL DBCHWAT(CLI_RETURN_CD, CONTEXT_PTR, WAIT_SESSID, WAIT_TOKEN); IF CLI_RETURN_CD = 0 THEN DO; OUT_TEXT = ’WAIT ERROR, RETURN CODE = ’ || CLI_RETURN_CD ; CALL ISRT_MSG; OUT_TEXT = DBCAREA.MSG_TEXT; CALL END_TRANS; END; DBCAREA.I_SESS_ID = SESSID(TOKEN_INDEX) ; DBCAREA.I_REQ_ID = REQID(TOKEN_INDEX); END CLI_WAIT; /* ************************************************************/ /* ***************** FETCH PARCELS */ CLI_FETCH_PARCELS: PROC; DBCAREA.FUNC = FETCH_FUNC ; CALL DBCHCL(CLI_RETURN_CD, CONTEXT_PTR, DBCAREA); IF (CLI_RETURN_CD = EOF_CODE) & (CLI_RETURN_CD = BUSY_CODE) & (CLI_RETURN_CD = CRASH_CODE) THEN CALL DISPLAY_PARCEL; END CLI_FETCH_PARCELS; /* **************************************************************/ /* *********** INITIATE INSERT REQUEST */ IRQ_CALL: PROC; DBCAREA.I_SESS_ID = SESSID(TOKEN_INDEX); DBCAREA.TOKEN = TOKEN_ARRAY.TOKEN(TOKEN_INDEX) ; DBCAREA.FUNC = INITIATE_REQ_FUNC ; CALL DBCHCL(CLI_RETURN_CD, CONTEXT_PTR, DBCAREA); IF CLI_RETURN_CD = 0 THEN DO; LAST_FUNCTION(TOKEN_INDEX) = ’INSERT’; REQID(TOKEN_INDEX) = DBCAREA.O_REQ_ID; TDPREQID(TOKEN_INDEX) = DBCAREA.TDP_REQ_NO; TRANS_COUNT = TRANS_COUNT + 1; DATA_FOR_INS_UPD.DATA1 = DATA_FOR_INS_UPD.DATA1 + 5; DATA_FOR_INS_UPD.DATA2 = DATA_FOR_INS_UPD.DATA2 + 5; DATA_FOR_INS_UPD.DATA3 = DATA_FOR_INS_UPD.DATA3 + 5; DATA_FOR_INS_UPD.DATA4 = DATA_FOR_INS_UPD.DATA4 + 5; DATA_FOR_INS_UPD.DATA5 = DATA_FOR_INS_UPD.DATA5 + 5; END; ELSE CALL DISP_ERROR; END IRQ_CALL; /* **************************************************************/ /* ***************** TERMINATE REQUEST *****/ CLI_END_REQUEST: PROC; DBCAREA.FUNC = END_REQUEST_FUNC; CALL DBCHCL(CLI_RETURN_CD, CONTEXT_PTR, DBCAREA); IF CLI_RETURN_CD = 0 THEN CALL DISP_ERROR; END CLI_END_REQUEST; /* *************************************************************/ /* ***************** DISCONNECT SESSION *****/ CLI_DISCONNECT: PROC; DBCAREA.FUNC = DISCONNECT_FUNC; CALL DBCHCL(CLI_RETURN_CD, CONTEXT_PTR, DBCAREA); IF CLI_RETURN_CD = 0 THEN CALL DISP_ERROR; END CLI_DISCONNECT; /* **************************************************************/ /* ***************** DISPLAY PARCEL *****/ DISPLAY_PARCEL: PROC; IF DBCAREA.FET_PARCEL_FLAVOR = ERROR_TYPE THEN DO; OUT_TEXT = ’ERROR PARCEL RECEIVED ’; CALL ISRT_MSG; OUT_TEXT = SUBSTR(ERROR_MSG,1,ERROR_LEN); CALL END_TRANS; END; ELSE IF DBCAREA.FET_PARCEL_FLAVOR = FAILURE_TYPE THEN DO; OUT_TEXT = ’FAILURE PARCEL RECEIVED ’; CALL ISRT_MSG; OUT_TEXT = SUBSTR(FAILURE_MSG,1,FAILURE_LEN); CALL END_TRANS; END; END DISPLAY_PARCEL; /* ***********************************************************/ /* ***************** DISPLAY ERROR MESSAGE *****/ DISP_ERROR: PROC; OUT_TEXT = ’FUNCTION = ’ || DBCAREA.FUNC || ’RETURN CODE = ’ || CLI_RETURN_CD; CALL ISRT_MSG; OUT_TEXT = DBCAREA.MSG_TEXT; CALL END_TRANS; END DISP_ERROR; /* ************************************************************/ /* ***************** INITIALIZE DBCAREA *****/ DBC_INIT: PROC; CALL DBCHINI(CLI_RETURN_CD, CONTEXT_PTR, DBCAREA); IF CLI_RETURN_CD = 0 THEN DO; OUT_TEXT = ’CLI RETURN CODE AFTER INIT = ’ || CLI_RETURN_CD; CALL ISRT_MSG; OUT_TEXT = DBCAREA.MSG_TEXT; CALL END_TRANS; END; END DBC_INIT; /* ***************** CONNECT SESSION *****/ CLI_CONNECT: PROC; TOKEN_INDEX = LOGID; DBCAREA.TOKEN = LOGID; DBCAREA.FUNC = CONNECT_FUNC; CALL DBCHCL(CLI_RETURN_CD, CONTEXT_PTR, DBCAREA); IF CLI_RETURN_CD = 0 THEN CALL DISP_ERROR; TDPREQID(TOKEN_INDEX) = DBCAREA.TDP_REQ_NO; NUMBER_OF_SESSIONS = NUMBER_OF_SESSIONS + 1; /* SAVE TOKEN, SESSION ID, REQUEST ID, AND LAST_FUNCTION */ TOKEN_ARRAY.TOKEN(TOKEN_INDEX) = LOGID; SESSID(TOKEN_INDEX) = DBCAREA.O_SESS_ID; REQID(TOKEN_INDEX) = DBCAREA.O_REQ_ID; LAST_FUNCTION(TOKEN_INDEX) = ’LOGON’; END CLI_CONNECT; /* ***********************************************************/ DBCAREA_SETUP: PROC; /* ***********************************************************/ /* * SET UP DBCAREA CONSTANTS */ /* * */ /* ***********************************************************/ /* *** SET UP POINTER TO DBC/SQL STATEMENT. */ DBCAREA.REQ_PTR= ADDR(MULTI_STMT_REQ); /* *** SET UP LENGTH OF DBC/SQL STATEMENT. */ DBCAREA.REQ_LEN = STG(MULTI_STMT_REQ); /* *** SET UP POINTER TO USING DATA */ DBCAREA.USING_DATA_PTR =ADDR(DATA_FOR_INS_UPD); /* *** SET UP LENGTH OF DATA FOR DBC/SQL STATEMENT. */ DBCAREA.USING_DATA_LEN = DATA_LEN; /* *** SET UP POINTER TO PARCEL AREA (MOVE MODE) */ /* CALL ’DBCHSAD’ USING CLI_RETURN_CD, */ /* DBC_FET_DATA_PTR, PARCEL. */ /* *** SET UP MAX SIZE FOR PARCEL (REQUIRED FOR MOVE MODE */ /* MOVE RESPBUF_SIZE TO DBC_FET_I_MAX_DATA_LEN. */ /* *** SET UP MAXIMUM NUMBER OF SESSIONS. */ DBCAREA.MAX_NUM_SESS = NUMLOG; /* ***********************************************************/ /* * */ /* * SET OPTION FLAGS */ /* ***********************************************************/ /* * SET MOVE MODE OPTION FOR COBOL PROGRAMS. */ /* * */ /* ***********************************************************/ /* MOVE ’N’ TO DBC_LOC_MODE. */ /* ***********************************************************/ /* * SET NO WAIT-FOR-RESPONSE OPTION. */ /* * (TECHNIQUE USED BY THIS SAMPLE PROGRAM) */ /* ***********************************************************/ DBCAREA.WAIT_FOR_RESP = ’N’; /* ***********************************************************/ /* * SET ’N’ FOR CRASH-WAIT OPTION. */ /* * (TECHNIQUE USED BY THIS SAMPLE PROGRAM) */ /* ***********************************************************/ DBCAREA.WAIT_ACROSS_CRASH = ’N’; /* ***********************************************************/ /* * SET ’Y’ FOR CRASH-TELL OPTION. */ /* * (TECHNIQUE USED BY THIS SAMPLE PROGRAM) */ /* ***********************************************************/ DBCAREA.TELL_ABOUT_CRASH = ’Y’; /* ***********************************************************/ /* * SET ’Y’ TO TRIGGER CHANGED OPTIONS. */ /* * */ /* ***********************************************************/ DBCAREA.CHANGE_OPTS = ’Y’; END DBCAREA_SETUP; IMMEDIATE_IMS_RETURN: END CLI2MPI;