EYUCAPI2
Program EYUCAPI2 is written in C for the CICS® enviornment.
About EYUxAPI2
This program does the following processing:
- Establishes a connection to the API.
- Defines a filter to identify PROGRAM resource table records with a language attribute of Assembler.
- Creates a result set containing all PROGRAM resource table records that do not begin with DFH, EYU, or IBM.
- Marks those records in the result set that match the specified filter (LANGUAGE=ASSEMBLER).
- Copies the marked records to a new result set.
- Deletes the marked records from the original result set.
- For each result set (LANGUAGE=ASSEMBLER and LANGUAGE≠ASSEMBLER):
- Retrieves each record.
- Translates any CICS CVDA attributes.
- Displays each record on the terminal.
- Terminates the API connection.
Commands used: CONNECT, COPY, DELETE,
FETCH, GET, LOCATE, MARK, SPECIFY FILTER, TERMINATE, TRANSLATE
/********************************************************************/
/* */
/* MODULE NAME = EYUCAPI2 */
/* */
/* DESCRIPTIVE NAME = CPSM Sample API Program 2 */
/* (Sample C Version) */
/* */
/* 5695-081 */
/* COPYRIGHT = NONE */
/* */
/* STATUS = %CP00 */
/* */
/* FUNCTION = */
/* */
/* To provide an example of the use of the following EXEC CPSM */
/* commands: CONNECT, SPECIFY FILTER, GET, MARK, COPY, DELETE, */
/* LOCATE, FETCH, TRANSLATE, TERMINATE. */
/* */
/* When invoked, the program depends upon the values held in the */
/* W_CONTEXT and W_SCOPE declarations when establishing a */
/* connection with CICSPlex SM. They must take the following */
/* values: */
/* */
/* W_CONTEXT = The name of a CMAS or CICSplex. Refer to the */
/* description of the EXEC CPSM CONNECT command */
/* for further information regarding the CONTEXT */
/* option. */
/* */
/* W_SCOPE = The name of a CICSplex, CICS system, or CICS */
/* system group within the CICSplex. Refer to the */
/* description of the EXEC CPSM CONNECT command */
/* for further information regarding the SCOPE */
/* option. */
/* */
/* This sample requires no parameters at invocation time. */
/* */
/* The sample establishes an API connection and issues a SPECIFY */
/* FILTER command to create a filter which will match only */
/* specific program resource table records. The filter is used */
/* later in the program by the MARK command. */
/* */
/* A GET command is issued to create a result set containing */
/* program resource table records which match the criteria. The */
/* result set is then used by the MARK command to flag records */
/* meeting the previous filter specification. The marked records */
/* are then COPYed to a new result set, and then DELETEd from */
/* the original result set. After this sequence of commands we */
/* have two results sets; one containing records which did not */
/* meet the filter specification (that is, records where the */
/* LANGUAGE is not ASSEMBLER), and one containing records */
/* which did match the filter (that is, records where the */
/* LANGUAGE is ASSEMBLER). */
/* */
/* Taking each of the two results sets in turn a LOCATE command */
/* is used to ensure we start at the top of the result set */
/* before a FETCH command is used to retrieve each record in */
/* the result set. Once retrieved the TRANSLATE command is used */
/* to convert those attributes of each record which are EYUDA */
/* or CVDA values into meaningful character representations. A */
/* record is then displayed on the terminal showing the program */
/* name, language, program status, and CEDF status. */
/* */
/* Finally, the API connection is terminated. */
/* */
* --------------------------------------------------------------------*
/*NOTES : */
/* DEPENDENCIES = S/390, CICS */
/* RESTRICTIONS = None */
/* REGISTER CONVENTIONS = */
/* MODULE TYPE = Executable */
/* PROCESSOR = C */
/* ATTRIBUTES = Read only, Serially Reusable */
/* */
/*------------------------------------------------------------------*/
/* */
/*ENTRY POINT = EYUCAPI2 */
/* */
/* PURPOSE = All Functions */
/* */
/* LINKAGE = From CICS either with EXEC CICS LINK or as a CICS */
/* transaction. */
/* */
/* INPUT = None. */
/* */
/*------------------------------------------------------------------*/
/* */
#include <PROGRAM>
void main()
{
/*------------------------------------------------------------------*/
/* CHANGE W_CONTEXT AND W_SCOPE TO MATCH YOUR INSTALLATION */
/*------------------------------------------------------------------*/
char *W_CONTEXT = "RTGA ";
char *W_SCOPE = "RTGA ";
int W_RESPONSE;
int W_REASON;
int W_THREAD;
char *W_CRITERIA;
int W_CRITERIALEN;
int W_FILTER_TOKEN;
int W_RESULT = 0;
int W_COUNT;
int W_RESULT2 = 0;
int W_COUNT2;
int III;
int JJJ;
int W_RESULT_TOK;
int W_RECCNT;
PROGRAM W_INTO_OBJECT;
int W_INTO_OBJECTLEN;
char W_TRANSCVDA??(12??);
char W_TEXT??(81??);
char W_MSG_TEXT??(81??);
W_TEXT??(80??) = 0x13;
W_MSG_TEXT??(80??) = 0x13;
/*------------------------------------------------------------------*/
/* OBTAIN A CPSM API CONNECTION. */
/* */
/* THE API WILL RETURN A TOKEN IDENTIFYING THE THREAD IN */
/* VARIABLE W_THREAD. */
/*------------------------------------------------------------------*/
strcpy(W_TEXT,"Establishing connection...");
/* printf("Establishing connection...\n"); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) ERASE;
EXEC CPSM CONNECT
CONTEXT(W_CONTEXT)
SCOPE(W_SCOPE)
VERSION("0310")
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_CONNECT; }
/*------------------------------------------------------------------*/
/* CREATE A FILTER. */
/* */
/* CREATE A FILTER WHICH WILL MATCH ONLY THOSE PROGRAMS WITH */
/* A LANGUAGE OF ASSEMBLER. */
/* THE FILTER WILL BE USED IN A SUBSEQUENT MARK COMMAND. */
/*------------------------------------------------------------------*/
strcpy(W_TEXT,"Create a filter... ");
/* printf("Create a filter...\n"); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
W_CRITERIA = "LANGUAGE=ASSEMBLER.";
W_CRITERIALEN = strlen(W_CRITERIA);
EXEC CPSM SPECIFY FILTER(W_FILTER_TOKEN)
CRITERIA(W_CRITERIA)
LENGTH(W_CRITERIALEN)
OBJECT("PROGRAM ")
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_FILTER; }
/*------------------------------------------------------------------*/
/* GET THE PROGRAM RESOURCE TABLE. */
/* */
/* CREATE A RESULT SET CONTAINING ENTRIES FOR ALL PROGRAMS */
/* WITH NAMES NOT BEGINNING DFH, EYU OR IBM. */
/* THE NUMBER OF ENTRIES MEETING THE CRITERIA IS RETURNED IN */
/* VARIABLE W_COUNT. */
/*------------------------------------------------------------------*/
strcpy(W_TEXT,"Get the PROGRAM resource table...");
/* printf("Get the PROGRAM resource table...\n"); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
W_CRITERIA = "NOT (PROGRAM=DFH* OR PROGRAM=EYU* OR PROGRAM=IBM*).";
W_CRITERIALEN = strlen(W_CRITERIA);
EXEC CPSM GET OBJECT("PROGRAM ")
CRITERIA(W_CRITERIA)
LENGTH(W_CRITERIALEN)
COUNT(W_COUNT)
RESULT(W_RESULT)
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_GET; }
sprintf(W_TEXT,"Total number of entries: %d", W_COUNT);
/* printf(W_TEXT); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
/*------------------------------------------------------------------*/
/* MARK SELECTED PROGRAM ENTRIES. */
/* */
/* USING THE FILTER WE MARK THOSE ENTRIES IN THE RESULT SET */
/* WHICH MEET THE FILTER SPECIFICATION IE. THOSE ENTRIES WITH */
/* A LANGUAGE OF ASSEMBLER. */
/*------------------------------------------------------------------*/
strcpy(W_TEXT,"Mark LANGUAGE=ASSEMBLER entries...");
/* printf("Mark LANGUAGE=ASSEMBLER entries...\n"); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
EXEC CPSM MARK FILTER(W_FILTER_TOKEN)
RESULT(W_RESULT)
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_MARK; }
/*------------------------------------------------------------------*/
/* COPY MARKED ENTRIES TO ANOTHER RESULT SET. */
/* */
/* HAVING MARKED ENTRIES IN THE RESULT SET WE CAN COPY THEM */
/* TO A NEW RESULT SET. */
/* AFTER THIS COMMAND WE WILL HAVE TWO RESULT SETS. ONE */
/* CONTAINING ALL THE PROGRAM ENTRIES, AND THE OTHER CONTAINING */
/* JUST THOSE ENTRIES WITH A LANGUAGE OF ASSEMBLER. */
/*------------------------------------------------------------------*/
strcpy(W_TEXT,"Copy marked entries... ");
/* printf("Copy marked entries...\n"); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
EXEC CPSM COPY FROM(W_RESULT)
TO(W_RESULT2)
MARKED
COUNT(W_COUNT2)
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_COPY; }
sprintf(W_TEXT,"Number of entries copied: %d", W_COUNT2);
/* printf(W_TEXT); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
/*------------------------------------------------------------------*/
/* DELETE MARKED ENTRIES FROM RESULT SET. */
/* */
/* WE CAN NOW DELETE THE MARKED ENTRIES FROM THE ORIGINAL */
/* RESULT SET. */
/* AFTER THIS COMMAND WE HAVE TWO RESULT SETS. ONE RESULT SET */
/* CONTAINING ENTRIES WITH LANGUAGE NOT ASSEMBLER, AND THE */
/* OTHER CONTAINING ENTRIES WITH A LANGUAGE OF ASSEMBLER. */
/*------------------------------------------------------------------*/
strcpy(W_TEXT,"Delete marked entries... ");
/* printf("Delete marked entries...\n"); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
EXEC CPSM DELETE MARKED
COUNT(W_COUNT)
RESULT(W_RESULT)
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_DELETE; }
sprintf(W_TEXT,"Number of entries remaining: %d", W_COUNT);
/* printf(W_TEXT); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
/*------------------------------------------------------------------*/
/* RETRIEVE INFORMATION ABOUT EACH PROGRAM. */
/* */
/* FETCH EACH ENTRY, USE INCLUDED STRUCTURE TO OBTAIN EACH */
/* ATTRIBUTE AND USE TRANSLATE TO CONVERT CICS CVDAS. */
/* DISPLAY DETAILS OF EACH PROGRAM TO THE USER. */
/*------------------------------------------------------------------*/
W_INTO_OBJECTLEN = PROGRAM_TBL_LEN;
for (JJJ = 1; JJJ <= 2; JJJ++)
{
if (JJJ == 1)
{
sprintf(W_TEXT,"Fetching %d non-ASSEMBLER PROGRAM entries...\n",
W_COUNT);
W_RESULT_TOK = W_RESULT;
W_RECCNT = W_COUNT;
}
else
{
sprintf(W_TEXT,"Fetching %d ASSEMBLER PROGRAM entries...\n",
W_COUNT2);
W_RESULT_TOK = W_RESULT2;
W_RECCNT = W_COUNT2;
}
/* printf(W_TEXT); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
EXEC CPSM LOCATE TOP
RESULT(W_RESULT_TOK)
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_LOCATE; }
strcpy(W_TEXT,"Program Language Status CEDF Status");
/* printf("Program Language Status CEDF Status\n"); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
for (III = 1; III <= W_RECCNT; III++)
{
EXEC CPSM FETCH INTO(&W_INTO_OBJECT)
LENGTH(W_INTO_OBJECTLEN)
RESULT(W_RESULT_TOK)
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_FETCH; }
memcpy(W_TEXT,W_INTO_OBJECT.PROGRAM,8);
EXEC CPSM TRANSLATE OBJECT("PROGRAM ")
ATTRIBUTE("LANGUAGE ")
FROMCV(W_INTO_OBJECT.LANGUAGE)
TOCHAR(W_TRANSCVDA)
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_TRANSLATE; }
memcpy(W_TEXT+9,W_TRANSCVDA,12);
EXEC CPSM TRANSLATE OBJECT("PROGRAM ")
ATTRIBUTE("STATUS ")
FROMCV(W_INTO_OBJECT.STATUS)
TOCHAR(W_TRANSCVDA)
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_TRANSLATE; }
memcpy(W_TEXT+22,W_TRANSCVDA,12);
EXEC CPSM TRANSLATE OBJECT("PROGRAM ")
ATTRIBUTE("CEDFSTATUS ")
FROMCV(W_INTO_OBJECT.CEDFSTATUS)
TOCHAR(W_TRANSCVDA)
THREAD(W_THREAD)
RESPONSE(W_RESPONSE)
REASON(W_REASON) ;
if (W_RESPONSE != EYUVALUE(OK)) { goto NO_TRANSLATE; }
memcpy(W_TEXT+35,W_TRANSCVDA,12);
/* printf("%s\n",W_TEXT); */
EXEC CICS SEND FROM(W_TEXT) LENGTH(81) WAIT;
}
}
goto ENDIT;
/*------------------------------------------------------------------*/
/* PROCESSING FOR API FAILURES. */
/*------------------------------------------------------------------*/
NO_CONNECT:
strcpy(W_MSG_TEXT,"ERROR CONNECTING TO API.\n");
goto SCRNLOG;
NO_FILTER:
strcpy(W_MSG_TEXT,"ERROR CREATING FILTER.\n");
goto SCRNLOG;
NO_GET:
strcpy(W_MSG_TEXT,"ERROR GETTING RESOURCE TABLE.\n");
goto SCRNLOG;
NO_MARK:
strcpy(W_MSG_TEXT,"ERROR MARKING RESULT SET.\n");
goto SCRNLOG;
NO_COPY:
strcpy(W_MSG_TEXT,"ERROR COPYING RESULT SET.\n");
goto SCRNLOG;
NO_DELETE:
strcpy(W_MSG_TEXT,"ERROR DELETING FROM RESULT SET.\n");
goto SCRNLOG;
NO_LOCATE:
strcpy(W_MSG_TEXT,"ERROR LOCATING TO TOP OF RESULT SET.\n");
goto SCRNLOG;
NO_FETCH:
strcpy(W_MSG_TEXT,"ERROR FETCHING RESULT SET.\n");
goto SCRNLOG;
NO_TRANSLATE:
strcpy(W_MSG_TEXT,"ERROR TRANSLATING ATTRIBUTE\n");
goto SCRNLOG;
SCRNLOG:
/* printf(W_MSG_TEXT); */
EXEC CICS SEND FROM(W_MSG_TEXT) LENGTH(81) WAIT;
sprintf(W_MSG_TEXT,"RESPONSE=%d REASON=%d\n",W_RESPONSE,W_REASON);
/* printf(W_MSG_TEXT); */
EXEC CICS SEND FROM(W_MSG_TEXT) LENGTH(81) WAIT;
ENDIT:
/*------------------------------------------------------------------*/
/* TERMINATE API CONNECTION. */
/*------------------------------------------------------------------*/
EXEC CPSM TERMINATE RESPONSE(W_RESPONSE) REASON(W_REASON);
EXEC CICS RETURN;
}
The C, C++, COBOL, and PL/I versions of EYUxAPI2 are written for the CICS environment and can be converted to run in the MVS batch environment by commenting the EXEC CICS SEND commands and uncommenting the preceding language specific output statements.