Sample program EYUCAPI2

Program EYUCAPI2 is written in C for the CICS® ENVIRONMENT.

EYUxAPI2
This program does the following: 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/370™, COBOL and PL/1 versions of EYUxAPI2 are written for the CICS environment and can be converted to run in the MVS/ESA batch environment by commenting the EXEC CICS SEND commands, and uncommenting the preceeding language specific output statements.

[[ Contents Previous Page | Next Page Index ]]