/*       ANALYZE SMF SYSTEM AND SUBSYSTEM UPTIME STATISTICS          */

 /* ----------------------------------------------------------------- */
 /*                                                                   */
 /* MODULE NAME: UPTIME                                               */
 /*                                                                   */
 /* AUTHOR: PETER FLASS                                               */
 /*         XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX                  */
 /*         JANUARY, 1992                                             */
 /*                                                                   */
 /* FUNCTION: ANALYZE SMF TYPE 23 (SMF STATUS), 0 (IPL) AND           */
 /*           30 (COMMON ADDRESS SPACE WORK) TO PRODUCE UPTIME        */
 /*           STATISTICS FOR SYSTEM AND CICS NETWORKS.                */
 /*                                                                   */
 /* MODIFICATIONS:                                                    */
 /*           01/05/94 - FIX MONTH LOGIC                           PRF*/
 /*           98/07/09 - BUMP RECORD COUNTS TO FIXED DEC(9)        PRF*/
 /*                      Y2K CHANGES (CALDATE0)                       */
 /*                                                                   */
 /* ----------------------------------------------------------------- */

 %PAGE;
 UPTIME: PROC OPTIONS(MAIN);

 %DCL    MAX_MON                   FIXED;
 %DCL    INT_TIME                  FIXED;
 %DCL    INT_PER_DAY               FIXED;
 %DCL    INT_PER_HOUR              FIXED;
 %DCL    DEBUG                     CHAR;
 %MAX_MON  = 10;
 %INT_TIME = 15;
 %INT_PER_DAY = (60/INT_TIME)*24;
 %INT_PER_HOUR= (60/INT_TIME);

 %DEBUG = 'NO';

 DCL     SMFDATA                   INPUT RECORD;
 DCL     SYSPRINT                  PRINT;
 DCL     PARMIN                    STREAM INPUT;

 DCL     EOF_SMF                   BIT(1)        INIT('0'B);
 DCL     RECORDS_READ              FIXED DEC(9)  INIT(0);
 DCL     RECORDS_SEL               FIXED DEC(9)  INIT(0);
 DCL   1 ERLY_DATE_TIME,
         5 ERLY_DATE               CHAR(10)      INIT('9999999999'),
         5 ERLY_TIME               CHAR(8)       INIT('99999999');
 DCL     ERLY_SER                  FIXED BIN(31);
 DCL   1 LATE_DATE_TIME,
         5 LATE_DATE               CHAR(10)      INIT('          '),
         5 LATE_TIME               CHAR(8)       INIT('        ');
 DCL     LATE_SER                  FIXED BIN(31);
 DCL   1 CURR_DATE_TIME,
         5 CURR_DATE               CHAR(10),
         5 CURR_TIME               CHAR(8);

 DCL     PRIME_INT                 FIXED BIN(15);
 DCL     PRIME_START               CHAR(4)       INIT('0800');
 DCL     PRIME_STOP                CHAR(4)       INIT('1659');

 DCL     START_DATE                CHAR(8)       INIT('19000101');
 DCL     STOP_DATE                 CHAR(8)       INIT('29991231');
 DCL    (START_SER,STOP_SER,CURR_SER)
                                   FIXED BIN(31);

 DCL     PAGENO                    FIXED DEC(5)  INIT(0);

 DCL     NUM_INTERVALS             FIXED BIN(31);
 DCL     STATBL                 (*)BIT(*)        ALIGNED CONTROLLED;

 DCL     MC                        FIXED BIN(15) INIT(0);
 DCL     MONITOR_TASK     (MAX_MON)CHAR(8);

 DCL     CHART_CNT                 FIXED BIN(31) INIT(0);
 DCL     CHART_POINTS         (*,*)FLOAT         CONTROLLED;
 DCL     CHART_LBLS             (*)CHAR(10)      CONTROLLED;
 DCL     CHART_SCALE            (*)FLOAT         CONTROLLED;

 DCL    (SEQDATEF,SEQDATET)        ENTRY         OPTIONS(ASM INTER);

 DCL     (
          ADDR,
          BOOL,
          CSTG,
          DATE,
          FIXED,                                         /* PF061793 */
          FLOAT,                                         /* PF061693 */
          FLOOR,
          HBOUND,
          INDEX,                                         /* PF061693 */
          LENGTH,
          MOD,
          NULL,
          PTRADD,
          STRING,
          SUBSTR,
          UNSPEC,
          VERIFY
         )
                                   BUILTIN;

 DCL     PLIDUMP                   BUILTIN;

 %INCLUDE(CALDATER);

 %INCLUDE(RPTHEAD);

 DCL     SUBHEAD                   CHAR(120)     INIT(' ');

 %PAGE;
 DCL     SMFP_SAVE                 POINTER;
 %INCLUDE(SMFC);                   /* SMF COMMON HEADER INFO         */
 %INCLUDE(SMF0);                   /* SMF TYPE 0 (IPL)               */
 %INCLUDE(SMF23);                  /* SMF TYPE 23 (SMF STATUS)       */
 %INCLUDE(SMF30);                  /* SMF TYPE 30 (COMMON ADDR WRK)  */

 %PAGE;

 ON ERROR CALL PLIDUMP('TFSHB');

 ON ENDFILE(SMFDATA)  EOF_SMF='1'B;
 ON ENDPAGE(SYSPRINT) CALL HED;

 H_ID    = 'UPTIME';
 H_DATE  = DATEFMT( DATE() );
 H_VERS  = '1.10';
 H_TITLE = CENTER('SUBSYSTEM UPTIME REPORT',H_TITLE);

 CALL READ_CONTROL;

 OPEN FILE(SMFDATA) INPUT;
 SUBHEAD = ' ';
 SUBHEAD = CENTER('L I S T I N G   O F   S M F   D A T A',SUBHEAD);
 SIGNAL ENDPAGE(SYSPRINT);

 READ FILE(SMFDATA) SET(SMFP);

 DO WHILE(^EOF_SMF);

     RECORDS_READ=RECORDS_READ+1;
     CURR_SER = CONVERT_JULIAN(SMF0DTE); /* GET RECORD DATE       */

     /* SAVE EARLIEST AND LATEST SMF TIMESTAMP                    */
     CURR_DATE= SMFDATEX(SMF0DTE);
     CURR_TIME= SMFTIME(SMF0TME);
     IF STRING(CURR_DATE_TIME)<STRING(ERLY_DATE_TIME)
     THEN DO;
       STRING(ERLY_DATE_TIME)=STRING(CURR_DATE_TIME);
       ERLY_SER = CONVERT_JULIAN(SMF0DTE);
       END;
     IF STRING(CURR_DATE_TIME)>STRING(LATE_DATE_TIME)
     THEN DO;
       STRING(LATE_DATE_TIME)=STRING(CURR_DATE_TIME);
       LATE_SER = CONVERT_JULIAN(SMF0DTE);
       END;

     SELECT(SMFXRTY);
       WHEN(00) CALL IPL;
       WHEN(23) CALL STATUS;
       WHEN(30) CALL ADDR_SPACE;
       OTHERWISE /* NULL */ ;
       END; /* SELECT */

     READ FILE(SMFDATA) SET(SMFP);

     END; /* DO WHILE */

 PUT SKIP(2) EDIT(RECORDS_READ,' SMF RECORDS READ')
                 (P'ZZZ,ZZZ,ZZ9',A);
 PUT SKIP(1) EDIT(RECORDS_SEL, ' SMF RECORDS SELECTED')
                 (P'ZZZ,ZZZ,ZZ9',A);
 PUT SKIP(2) EDIT('EARLIEST TIMESTAMP ',ERLY_DATE,' ',ERLY_TIME)(A);
 PUT SKIP(1) EDIT('LATEST   TIMESTAMP ',LATE_DATE,' ',LATE_TIME)(A);

 CALL PRINT_STATUS;

 RETURN;

 %PAGE;
 /********************************************************************/
 /*      P R O C E S S   S M F   R E C O R D S                       */
 /********************************************************************/

 /*-------------------------------*/
 /* PROCESS IPL EVENT             */
 /*-------------------------------*/

 IPL: PROC;

   DCL   EVENT                     FIXED BIN(31);

   /* COMPUTE WHERE THIS EVENT OCCURS */
   EVENT = EVENT_TIME(SMF0DTE,SMF0TME);
   IF EVENT<0 THEN RETURN;

   /* TURN ON INTERVAL IPL BIT                             */
   SUBSTR(STATBL(EVENT),1,1)='1'B;

   PUT SKIP EDIT (SMF0DTE,' ',SMFTIME(SMF0TME),' IPL')   /* PF061793 */
                 (P'99.999',A,A,A);                      /* PF061793 */

   RECORDS_SEL = RECORDS_SEL + 1;

 END IPL;

 %SKIP(2);
 /*-------------------------------*/
 /* PROCESS SMF STATUS EVENT      */
 /*-------------------------------*/

 STATUS: PROC;

   DCL   EVENT                     FIXED BIN(31);

   /* COMPUTE WHERE THIS EVENT OCCURS */
   EVENT = EVENT_TIME(SMF23DTE,SMF23TME);
   IF EVENT<0 THEN RETURN;

   /* TURN ON INTERVAL STATUS BIT                          */
   SUBSTR(STATBL(EVENT),2,1)='1'B;

   /* DO NOT REPORT STATUS EVENTS     */

   RECORDS_SEL = RECORDS_SEL + 1;

 END STATUS;

 %PAGE;
 /*-------------------------------*/
 /* PROCESS ADDRESS SPACE EVENT   */
 /*-------------------------------*/

 ADDR_SPACE: PROC;

   DCL   EVENT                     FIXED BIN(31);
   DCL   SCC_TEXT                  CHAR(10);             /* PF061793 */
   DCL   SCC_FWD                   FIXED BIN(31);
   DCL   SCC_CHAR8                 CHAR(8);
   DCL   J                         FIXED BIN(15);
   DCL   TEMP                      BIT(MC*2+2)   INIT('0'B);
   DCL   TASK                      CHAR(8);
   DCL   ST                        FIXED BIN(15);

   /* TEST FOR SUBTYPE 1 (JOB START)  */
   /*      AND SUBTYPE 5 (JOB END)    */
   ST = SMF30STP;
   IF ST ^= 1 & ST ^= 5
   THEN RETURN;

   /* DO WE HAVE IDENTIFICATION SECT? */
   IF SMF30ION < 1 THEN RETURN;

   /* COMPUTE WHERE THIS EVENT OCCURS */
   EVENT = EVENT_TIME(SMF30DTE,SMF30TME);
   IF EVENT<0 THEN RETURN;

   SMFP_SAVE = SMFP;
   SMFP = PTRADD(SMFP,SMF30IOF-4);
   TASK = SMF30JBN;

   DO J=1 TO MC;
     IF TASK = MONITOR_TASK(J) THEN LEAVE;
     END;
   IF J>MC THEN RETURN;

 %PAGE;

   SMFP = SMFP_SAVE;

   /*----------------------------------------------------------------*/
   /* TURN ON START OR STOP BIT FOR THIS INTERVAL.                   */
   /* SINCE SMF RECORDS ARE IN TIME ORDER, IF A START PRECEDES       */
   /* A STOP IN THE SAME INTERVAL WE SHOULD TURN OFF THE START BIT   */
   /* SO THAT THE TASK WILL BE CONSIDERED 'DOWN' FOR THE ENTIRE      */
   /* INTERVAL.  IF A STOP PRECEDES A START WE CAN LEAVE BOTH BITS   */
   /* SET TO INDICATE THAT THE TASK WAS UP FOR ONLY PART OF THE      */
   /* INTERVAL.                                                      */
   /*----------------------------------------------------------------*/

   TEMP = STATBL(EVENT);               /* GET INTERVAL INFO          */
   J = J * 2 + 1;                      /* GET LOC OF TASK BITS       */
   IF ST = 1                           /* IS THIS A START?           */
   THEN SUBSTR(TEMP,J,1)='1'B;         /* .. YES, TURN ON START BIT  */
   ELSE SUBSTR(TEMP,J,2)='01'B;        /* .. NO, TURN ON STOP&OFF STR*/
   STATBL(EVENT) = TEMP;               /* RESTORE INTERVAL STATE     */

   IF SMF30TON > 0 THEN DO;
     SMFP = PTRADD(SMFP,SMF30TOF-4);
     IF SUBSTR(SMF30STI,7,1)='0'B
     THEN PUT STRING(SCC_TEXT) EDIT('RC=',SMF30SCC)(A,P'9999');
     ELSE DO;
       SCC_FWD   = SMF30SCC;
       SCC_CHAR8 = UNPACK(SCC_FWD);
       IF SMF30SCC < 0
       THEN SCC_TEXT = 'ABEND U'³³SUBSTR(SCC_CHAR8,6,3); /* PF061793 */
       ELSE SCC_TEXT = 'ABEND S'³³SUBSTR(SCC_CHAR8,6,3); /* PF061793 */
       END;
     END; /* SMF30TON>0 */

   SMFP = SMFP_SAVE;

   IF ST = 1 THEN DO;
     PUT SKIP EDIT (SMF30DTE,' ',SMFTIME(SMF30TME),      /* PF061793 */
                    ' ',TASK,' STARTED')                 /* PF061793 */
                   (P'99.999',A,A,A,A,A);                /* PF061793 */
     END;
   ELSE DO;
     PUT SKIP EDIT (SMF30DTE,' ',SMFTIME(SMF30TME),      /* PF061793 */
                    ' ',TASK,' ENDED - ',SCC_TEXT)       /* PF061793 */
                   (P'99.999',A,A,A,A,A,A);              /* PF061793 */
     END;

   RECORDS_SEL = RECORDS_SEL + 1;

 END ADDR_SPACE;

 %PAGE;

 /*------------------------------------------------*/
 /* COMPUTE EVENT DATE & TIME INTERVAL POINTER     */
 /*------------------------------------------------*/

 EVENT_TIME: PROC(DATE,TIME) RETURNS( FIXED BIN(31) );

 DCL     DATE                      FIXED DEC(7);
 DCL     TIME                      FIXED BIN(31);

 DCL     SER                       FIXED BIN(31);
 DCL     TOD                       CHAR(6);
 DCL     HR                        PIC '99';
 DCL     MN                        PIC '99';
 DCL     X                         FIXED BIN(31);

 SER  = CONVERT_JULIAN(DATE);
 IF SER<START_SER ³ SER>STOP_SER THEN RETURN(-1);

 TOD = SMFTIMEX(TIME);
 HR  = SUBSTR(TOD,1,2);
 MN  = SUBSTR(TOD,3,2);

 /* COMPUTE START OF DAY    */
 X = (SER-START_SER) * INT_PER_DAY;

 /* COMPUTE INTERVAL IN DAY */
 MN =  MN / 15;
 X = X + (HR*4) + MN + 1;

 RETURN(X);

 END EVENT_TIME;

 %PAGE;
 /********************************************************************/
 /*      P R I N T   S T A T U S   R E P O R T                       */
 /********************************************************************/

 PRINT_STATUS: PROC;

   DCL  (I,J,K)                    FIXED BIN(31);
   DCL   TEMP                      BIT(MC*2+2)   INIT('0'B);
   DCL   STATE                 (MC)BIT(1)        INIT((MC)('0'B));
   DCL  (SN,SK)                    BIT(1);
   DCL  (HH,MM)                    FIXED BIN(15);
   DCL  (T_I,T_P)              (MC)FIXED BIN(15) INIT((MC)(0));
   DCL   HHMM                      PIC '9999';
   DCL   SDATE                     FIXED BIN(31);
   DCL   CDATE                     CHAR(8);
   DCL   PRIME                     BIT(1);
   DCL  (ST,EN)                    FIXED BIN(31);

 /*----------------------------------------------------------------*/
 /* FIGURE OUT THE STATUS OF EACH MONITORED TASK IN EACH INTERVAL  */
 /*----------------------------------------------------------------*/

 SDATE = START_SER - 1;

 DO J = 1 TO NUM_INTERVALS;

   MM = MOD(J,4) * 15;                     /* GET INTERVAL TIME    */
   HH = MOD(J/4,24);
   HHMM = HH * 100 + MM;
   IF HHMM>=PRIME_START & HHMM<PRIME_STOP  /* CHECK FOR PRIME SHIFT*/
   THEN PRIME='1'B;
   ELSE PRIME='0'B;

   TEMP = STATBL(J);                       /* GET INTERVAL STATUS  */

   DO K = 1 TO MC;                         /* DO EACH TASK         */

     /*------------------------------------------------------------*/
     /* FIRST SEE IF THIS TASK HAS CHANGED STATE IN THIS INTERVAL  */
     /* (SEE NOTE ABOVE - IF TASK STARTS AND STOPS IN SAME         */
     /*  INTERVAL ONLY THE STOP WILL BE INDICATED, I.E. THE STATE  */
     /*  WILL BE 'STOPPED'.  IF THE TASK STOPS AND THEN STARTS     */
     /*  IN THE INTERVAL BOTH WILL BE INDICATED, BUT THE STATE     */
     /*  WILL STILL BE 'STOPPED'.                                  */
     /*  THEREFORE THE TASK MUST BE UP FOR THE WHOLE INTERVAL IN   */
     /*  ORDER TO BE CONSIDERED UP _DURING_ THAT INTERVAL.         */
     /*  THIS IS COMPENSATED FOR BY COUNTING THE INTERVAL IN WHICH */
     /*  THE TASK STARTS AS 'UPTIME'.                              */
     /*------------------------------------------------------------*/

     SN,SK = STATE(K);                     /* STATE IN PREV INTVL  */

     /*  IF STARTED THIS INTERVAL SET 'STARTED' STATUS             */
     IF SUBSTR(TEMP,2*K+1,1)='1'B THEN SN,SK='1'B;

     /*  IF STOPPED THIS INTERVAL SET 'STOPPED' STATUS             */
     IF SUBSTR(TEMP,2*K+2,1)='1'B THEN SN,SK='0'B;

     /*  IF STOPPED AND STARTED, CURRENT STATUS IS 'STOPPED'       */
     /*  BUT NEXT STATUS IS 'STARTED'.                             */
     IF SUBSTR(TEMP,2*K+1,2)='11'B THEN DO;
       SN = '1'B;
       SK = '0'B;
       END;

     /*------------------------------------------------------------*/
     /* NEXT WE MUST HAVE EITHER AN IPL OR A STATUS EVENT IN THIS  */
     /* INTERVAL.  IF NOT THE SYSTEM HAS CRASHED AND THE TASK      */
     /* STATE IS 'STOPPED'                                         */
     /*------------------------------------------------------------*/

     IF SUBSTR(TEMP,1,2)='00'B THEN SN,SK='0'B;

     /*------------------------------------------------------------*/
     /* FINALLY(!) SET THE TASK STATUS TO THE STAUTS CALCULATED    */
     /* IN THE PRECEDING STEPS. (USE 'STARTED' BIT TO INDICATE     */
     /* STATUS.  THEN SET THE CARRYOVER STATE FOR THE NEXT         */
     /* INTERVAL.                                                  */
     /*------------------------------------------------------------*/

     SUBSTR(TEMP,2*K+1,1) = SK;
     STATE(K) = SN;

     END /* DO K */ ;

     STATBL(J) = TEMP;                     /* RESTORE INTRVL STATUS*/

   END /* DO J */ ;

 /*----------------------------------------------------------------*/
 /* ADJUST TASK START TIME TO ALLOW FOR RECORDS SKIPPED            */
 /*----------------------------------------------------------------*/

 SDATE = START_SER - 1;

 DO K = 1 TO MC;                           /* DO EACH TASK         */

   DO J = 1 TO NUM_INTERVALS;

     TEMP = STATBL(J);                     /* GET INTERVAL STATUS  */

     /* FIND FIRST EVENT FOR THIS TASK                             */
     IF SUBSTR(TEMP,2*K+1,2)^='00'B THEN LEAVE /* J */ ;

     END /* DO J */ ;

   /*--------------------------------------------------------------*/
   /*  IF FIRST EVENT IS 'STOP' THEN TASK WAS STARTED PRIOR TO     */
   /*  FIRST SMF RECORD READ.  BACK UP AND FILL IN 'RUNNING'       */
   /*  STATUS AS LONG AS SYSTEM IS UP.                             */
   /*--------------------------------------------------------------*/

   IF SUBSTR(TEMP,2*K+2,1)='1'B
   THEN DO I=J-1 TO 1 BY -1;
     TEMP = STATBL(I);                     /* GET INTERVAL STATUS  */
     IF SUBSTR(TEMP,2,1)='1'B              /* .. SYSTEM IS UP      */
     THEN SUBSTR(TEMP,2*K+1,1)='1'B;       /* .. SET 'RUNNING' BIT */
     STATBL(I) = TEMP;                     /* RESTORE INTRVL STATUS*/
     END /* DO I */ ;

   END /* DO K */ ;

 %PAGE;
 /*----------------------------------------------------------------*/
 /*     G E N E R A T E   R E P O R T S                            */
 /*----------------------------------------------------------------*/

 SUBHEAD = ' ';
 SUBHEAD = CENTER('S U B S Y S T E M   U P T I M E   R E P O R T',
                  SUBHEAD);
 SIGNAL ENDPAGE(SYSPRINT);
 PUT SKIP LIST('*--------------------------------------'³³
               '--------------------------------------*');
 PUT SKIP LIST('³ TABLE SHOWS TOTAL UPTIME AND PRIME-SH'³³
               'IFT UPTIME IN MINUTES.                ³');
 PUT SKIP LIST('³ PERCENTAGES SHOW PORTION OF 24-HOUR D'³³
               'AY AND OF PRIME SHIFT THAT THE        ³');
 PUT SKIP LIST('³ INDICATED SUBSYSTEM WAS AVAILABLE.   '³³
               '                                      ³');
 PUT SKIP LIST('³                                      '³³ /* 061793 */
               '                                      ³'); /* 061793 */
 PUT SKIP EDIT('³ PRIME SHIFT IS ',                        /* 061793 */
                  SUBSTR(PRIME_START,1,2)³³':'³³           /* 061793 */
                  SUBSTR(PRIME_START,3,2)³³' TO '³³        /* 061793 */
                  SUBSTR(PRIME_STOP,1,2)³³':'³³            /* 061793 */
                  SUBSTR(PRIME_STOP,3,2),                  /* 061793 */
               ' MON-FRI.                                     ³')(A);
 PUT SKIP LIST('³ TABLE AND CHART EXCLUDE WEEKENDS.    '³³ /* 061793 */
               '                                      ³'); /* 061793 */
 PUT SKIP LIST('³                                      '³³ /* 061793 */
               '                                      ³'); /* 061793 */
 PUT SKIP LIST('*--------------------------------------'³³
               '--------------------------------------*');
 PUT SKIP;

 /* DO NOT PRINT DATES OUT OF RANGE OF SMF DATA WE HAVE            */
 ST = START_SER;
 IF START_SER<ERLY_SER THEN DO;            /* DESIRED<1ST SMF REC? */
   PUT SKIP EDIT('*** DATA NOT AVAILABLE BEFORE ',ERLY_DATE)(A);
   ST = ERLY_SER;
   END;
 EN = STOP_SER;
 IF STOP_SER>LATE_SER THEN EN = LATE_SER;  /* DESIRED>LAST SMF?    */

 IF EN<ST THEN DO;
   PUT SKIP LIST('*** NO DATA TO PRINT');
   RETURN;
   END;

 SDATE = ST-1;
 ST = ST - START_SER;
 EN = EN - START_SER + 1;

 /*----------------------------------------------------------------*/
 /*     A L L O C A T E   C H A R T   D A T A                      */
 /*----------------------------------------------------------------*/

 ALLOCATE CHART_POINTS  (EN-ST,MC);
 ALLOCATE CHART_LBLS    (EN-ST);
 ALLOCATE CHART_SCALE   (EN-ST);

 ST = ST  * INT_PER_DAY + 1;
 EN = EN  * INT_PER_DAY;

 DO J = ST TO EN;

   IF MOD(J-1,INT_PER_DAY)=0 THEN DO;      /* START OF NEW DAY?    */
     IF J>ST THEN DO;                      /* (START FIRST DAY)    */
       IF MOD(SDATE,7)^=0 & MOD(SDATE,7)^=6/* SKIP SAT AND SUN     */
       THEN CALL PRINT_TOTALS(SDATE,T_I,T_P);
       END;
     SDATE = SDATE + 1;
     T_I,T_P = 0;                          /* CLEAR TOTALS         */
     END;

   MM = MOD(J,4) * 15;                     /* GET INTERVAL TIME    */
   HH = MOD(J/4,24);
   HHMM = HH * 100 + MM;
   IF HHMM>=PRIME_START & HHMM<PRIME_STOP  /* CHECK FOR PRIME SHIFT*/
   THEN PRIME='1'B;
   ELSE PRIME='0'B;

   TEMP = STATBL(J);                       /* GET INTERVAL STATUS  */

   /*--------------------------------------------------------------*/
   /*    PRINT UPTIME FOR EACH TASK                                */
   /*--------------------------------------------------------------*/

   DO K = 1 TO MC;                         /* DO EACH TASK         */

     IF SUBSTR(TEMP,2*K+1,1)='1'B THEN DO;
       T_I(K) = T_I(K) + 1;
       IF PRIME THEN T_P(K) = T_P(K) + 1;
       END /* IF SUBSTR */ ;

     END /* DO K */ ;

   END /* DO J */ ;

   IF MOD(SDATE,7)^=0 & MOD(SDATE,7)^=6    /* SKIP SAT AND SUN     */
   THEN CALL PRINT_TOTALS(SDATE,T_I,T_P);  /* PRINT LAST DAY TOTALS*/

   IF STOP_SER>LATE_SER THEN DO;
     PUT SKIP(2) EDIT('*** DATA NOT AVAILABLE AFTER ',LATE_DATE)(A);
     END;

 CALL PRINT_THE_CHART;

 END PRINT_STATUS;

 /*----------------------------------------------------------------*/
 /* PRINT TOTAL UPTIME BY TASK BY DAY                              */
 /*----------------------------------------------------------------*/

 PRINT_TOTALS: PROC(SDATE,TOT,PRIME);

 DCL     SDATE                    FIXED BIN(31);
 DCL     TDATE                    CHAR(14);
 DCL     CDATE                    CHAR(8);
 DCL    (TOT,PRIME)            (*)FIXED BIN(15);

 DCL     I                         FIXED BIN(15);
 DCL    (TOT_PERC,PRIME_PERC)      FIXED DEC(3);
 DCL    (TOT_MIN,PRIME_MIN)        FIXED DEC(5);
 DCL     DOW                  (0:6)CHAR(3) STATIC INIT
              ('SUN','MON','TUE','WED','THU','FRI','SAT');

 F1: FORMAT(A(14),X(3),A(8),X(2),
            (2)(X(5),P'ZZZ9'),(2)(X(5),P'ZZ9',A) );
 F2: FORMAT(A(14),X(3),A(8),X(2),
            (2)(X(1),A(8)),(2)(X(1),A(8)) );

 CALL SEQDATEF(CDATE,SDATE);
 PUT STRING(TDATE) EDIT
           (DOW(MOD(SDATE,7))³³' '³³SUBSTR(CDATE,1,4)³³'-'³³
            SUBSTR(CDATE,5,2)³³'-'³³SUBSTR(CDATE,7,2))(A);

 PUT SKIP(2) EDIT('       DATE   ',' TASK  ','   TOTAL','   PRIME',
                  '       %','       %')
                 (R(F2));
 PUT SKIP    EDIT('              ','       ','  UPTIME','  UPTIME',
                  '   TOTAL','   PRIME')
                 (R(F2));

 CHART_CNT = CHART_CNT + 1;
 CHART_LBLS(CHART_CNT) = SUBSTR(TDATE,5);
 CHART_SCALE(CHART_CNT) = CHART_CNT;

 DO I = 1 TO MC;

   /* CONVERT # INTERVALS TO MINUTES FOR TABLE                     */
   TOT_MIN    = TOT(I)   * INT_TIME;
   PRIME_MIN  = PRIME(I) * INT_TIME;

   TOT_PERC   = TOT(I)   / INT_PER_DAY * 100;
   PRIME_PERC = PRIME(I) / PRIME_INT   * 100;

   /* CONVERT # INTERVALS TO HOURS FOR CHART                       */
   CHART_POINTS(CHART_CNT,I) = FLOAT( TOT(I) ) / INT_PER_HOUR;

   PUT SKIP EDIT(TDATE,MONITOR_TASK(I),TOT_MIN,PRIME_MIN,
                 TOT_PERC,'%',PRIME_PERC,'%')(R(F1));

   TDATE = ' ';

   END /* DO I */ ;

 PUT SKIP;

 END PRINT_TOTALS;

 %PAGE;
 /*----------------------------------------------------------------*/
 /* GENERATE THE  CHART                                            */
 /*----------------------------------------------------------------*/

 PRINT_THE_CHART: PROCEDURE;

 DCL    (I,J)                     FIXED BIN(15);
 DCL     CHART_POINTSX
                    (MC*CHART_CNT)FLOAT;
 DCL     P_LIST                (1)FIXED BIN(31);
 DCL     N_LIST                (1)CHAR(8)        INIT('CHART');
 DCL     HEADING                  CHAR(120)      VARYING;
 /* OVERRIDE DEFAULT MARK CHARACTERS                        PF061793 */
 DCL     CHART_MARKS            (8)FIXED BIN(31) INIT    /* PF061793 */
                              (8,7,6,4,3,2,1,5);         /* PF061793 */

 /* COPY DATA VALUES INTO ARRAY FOR GDDM                 */
 /* (THIS CAN'T BE DONE EARLIER SINCE WE DON'T KNOW      */
 /*  HOW MAY DAYS WE'RE PLOTTING, AND THE ARRAY HAS TO   */
 /*  BE ARRANGED BY COMPONENT [TASK]).                   */
 DO I=1 TO CHART_CNT;
   DO J=1 TO MC;
     CHART_POINTSX((J-1)*CHART_CNT+I) = CHART_POINTS(I,J);
     END /* DO J */ ;
   END /* DO I */ ;

 /* INITIALIZE GDDM                                      */
 CALL FSINIT;

 /* OPEN DEFAULT OUTPUT DEVICE = FAMILY-4 PRINTER (3800) */
 /* TOKEN 'P38PPW3' INDICATES LANDSCAPE FORMAT           */
 CALL DSOPEN(0,4,'P38PPW3',0,P_LIST,1,N_LIST);

 /* LOAD CHART HEADINGS AND TITLES                       */
 CALL CHMARK( FIXED(HBOUND(CHART_MARKS,1),31), CHART_MARKS );/* 1793 */
 HEADING = 'SUBSYSTEM UPTIME '³³CHART_LBLS(1)³³
            ' TO '³³CHART_LBLS(CHART_CNT);
 CALL CHHEAD(LENGTH(HEADING),HEADING);
 HEADING = 'UPTIME (HR)';
 CALL CHYTTL(LENGTH(HEADING),HEADING);
 HEADING = 'DAY';
 CALL CHXTTL(LENGTH(HEADING),HEADING);

 /* SET X-RANGE = NUMBER OF DAYS TO BE PLOTTED           */
 CALL CHXRNG(1,CHART_CNT);

 /* X-RANGE LABELS = DATES                               */
 CALL CHXDLB(CHART_CNT,LENGTH(CHART_LBLS(1)),CHART_SCALE,CHART_LBLS);

 /* Y-AXIS DATUM LINE = HOURS IN PRIME SHIFT             */
 CALL CHYDTM(FLOAT(PRIME_INT) / INT_PER_HOUR );

 /* LEGEND KEY LABELS - LIST OF TASKS                    */
 CALL CHKEY(MC,LENGTH(MONITOR_TASK(1)),MONITOR_TASK);

 /* DRAW THE GRAPH                                       */
 CALL CHPLOT(MC,CHART_CNT,CHART_SCALE,CHART_POINTSX);

 /* TERMINATE THE CHART                                  */
 CALL CHTERM;
 /* FORCE OUTPUT TO PRINTER                              */
 CALL FSFRCE;
 /* TERMINATE GDDM                                       */
 CALL FSTERM;

 END PRINT_THE_CHART;

 %PAGE;
 /********************************************************************/
 /*      R E A D   C O N T R O L   C A R D S                         */
 /********************************************************************/

 READ_CONTROL: PROC;

 DCL     EOF_PARMIN                BIT(1)        INIT('0'B);
 DCL     CARD                      CHAR(80)      VARYING;
 DCL     X                         CHAR(2);
 DCL     J                         FIXED BIN(15);
 DCL     MONTH_NAME                CHAR(9);              /* PF061793 */
 DCL     THIS_YEAR                 CHAR(4);              /* PF061793 */

 ON ENDFILE(PARMIN) EOF_PARMIN='1'B;

 OPEN FILE(PARMIN) INPUT;
 GET FILE(PARMIN) EDIT(CARD)(A(80));

 SUBHEAD = ' ';
 SUBHEAD=CENTER('C O N T R O L   C A R D   L I S T I N G',SUBHEAD);
 SIGNAL ENDPAGE(SYSPRINT);

 DO WHILE(EOF_PARMIN = '0'B);
   PUT SKIP LIST(CARD);
   IF LENGTH(CARD)>72 THEN CARD=SUBSTR(CARD,1,72);
   IF SUBSTR(CARD,1,1)='*'                  /* BYPASS COMMENTS       */
   THEN /* NULL */ ;
   ELSE IF CARD=' '                         /* .. BLANK CARDS        */
   THEN /* NULL */ ;
   /* DATES AS YYYYMMDD                                     PF061793 */
   ELSE IF SUBSTR(CARD,1,6)='START '        /* START DATE            */
   THEN START_DATE=PARSE(CARD,7);
   ELSE IF SUBSTR(CARD,1,4)='END '          /* END DATE              */
   THEN STOP_DATE=PARSE(CARD,5);
   /*                                                       PF061793 */
   ELSE IF SUBSTR(CARD,1,12)='PRIME START ' /* SHIFT START TIME      */
   THEN PRIME_START=PARSE(CARD,13);
   ELSE IF SUBSTR(CARD,1,10)='PRIME END '   /* SHIFT END TIME        */
   THEN PRIME_STOP=PARSE(CARD,11);
   ELSE IF SUBSTR(CARD,1,8)='MONITOR '      /* TASKS TO MONITOR      */
   THEN DO;
     IF MC>=MAX_MON THEN DO;
       PUT STRING(X) EDIT(MAX_MON)(P'Z9');
       PUT SKIP EDIT('** MAXIMUM OF ',X,' MONITORED TASKS EXCEEDED')(A);
       SIGNAL ERROR;
       END;
     MC=MC+1;
     MONITOR_TASK(MC)=PARSE(CARD,9);
     END;
   ELSE IF SUBSTR(CARD,1,06)='MONTH '       /* MONTH NAME   PF061793 */
   THEN DO;                                              /* PF061793 */
       MONTH_NAME=PARSE(CARD,7);                         /* PF061793 */
       THIS_YEAR=PARSE(CARD,1);                          /* PF061793 */
       CALL PROC_MONTH(MONTH_NAME,THIS_YEAR);            /* PF061793 */
       END;                                              /* PF061793 */
                                            /* ALL OTHER CARDS       */
   ELSE PUT SKIP LIST('** INVALID CONTROL CARD IGNORED');
   GET FILE(PARMIN) EDIT(CARD)(A(80));
   END; /* DO WHILE */

 CLOSE FILE(PARMIN);

 CALL EDIT_DATE(START_DATE);
 CALL EDIT_DATE(STOP_DATE);

 CALL EDIT_TIME(PRIME_START);
 CALL EDIT_TIME(PRIME_STOP);

 IF START_DATE>STOP_DATE THEN DO;
   PUT SKIP EDIT('** START DATE ',START_DATE,' AFTER STOP DATE ',
                  STOP_DATE)(A);
   SIGNAL ERROR;
   END;

 IF PRIME_START>PRIME_STOP THEN DO;
   PUT SKIP EDIT('** SHIFT START TIME ',PRIME_START,
                  ' AFTER STOP TIME ',PRIME_STOP)(A);
   SIGNAL ERROR;
   END;

 IF MC = 0 THEN DO;
   PUT SKIP LIST('** NO TASKS TO MONITOR');
   SIGNAL ERROR;
   END;

 CALL SEQDATET(START_DATE,START_SER);
 PUT SKIP EDIT('START=',START_DATE)(A);
 CALL SEQDATET(STOP_DATE,STOP_SER);
 PUT SKIP EDIT('STOP= ',STOP_DATE)(A);

 CALL ALLOC_STATUS;

 CALL COMPUTE_PRIME_SHIFT;

 CALL SORT_TASK_NAMES;

 SUBHEAD = ' ';
 SUBHEAD=CENTER(' P A R A M E T E R S   F O R   '³³
                'T H I S   R U N',SUBHEAD);
 SIGNAL ENDPAGE(SYSPRINT);

 PUT SKIP(2) EDIT('ANALYZING DATA FROM ',
                  SUBSTR(START_DATE,1,4)³³'-'³³
                  SUBSTR(START_DATE,5,2)³³'-'³³
                  SUBSTR(START_DATE,7,2) )(A);

 PUT SKIP(1) EDIT('                 TO ',
                  SUBSTR(STOP_DATE,1,4)³³'-'³³
                  SUBSTR(STOP_DATE,5,2)³³'-'³³
                  SUBSTR(STOP_DATE,7,2) )(A);

 PUT SKIP(2) EDIT('PRIME SHIFT TIMES ARE ',
                  SUBSTR(PRIME_START,1,2)³³':'³³
                  SUBSTR(PRIME_START,3,2),' TO ',
                  SUBSTR(PRIME_STOP,1,2)³³':'³³
                  SUBSTR(PRIME_STOP,3,2) )(A);
 PUT         EDIT(', LENGTH ',PRIME_INT*INT_TIME,' MINUTES.')
                 (A,P'ZZZ9',A);

 PUT SKIP(2) LIST('MONITORED TASKS:');
 PUT SKIP(1) LIST('    ');
 PUT         EDIT( ((MONITOR_TASK(J),' ') DO J=1 TO MC) )(A);

 PUT SKIP(2) EDIT(CSTG(STATBL),' BYTES REQUIRED FOR WORK AREA')
                 (P'ZZZ,ZZZ,ZZ9',A);

 END READ_CONTROL;

 /*-------------------------------*/
 /* SCAN ONE PARAMETER            */
 /*-------------------------------*/

 PARSE: PROC(S,P) RETURNS( CHAR(72) VARYING );

 DCL     S                         CHAR(80)      VARYING;
 DCL     P                         FIXED BIN(15);
 DCL     W                         CHAR(72)      VARYING   INIT('');

 IF P>LENGTH(S) THEN RETURN('');
 S=SUBSTR(S,P);

 DO WHILE(LENGTH(S)>0);
   IF SUBSTR(S,1,1)=' ' THEN S=SUBSTR(S,2);
   ELSE DO;
     W=W³³SUBSTR(S,1,1);
     S=SUBSTR(S,2);
     IF LENGTH(S)=0 ³ (LENGTH(S)>0) & (SUBSTR(S,1,1)=' ')/* PF061793 */
     THEN RETURN(W);                                     /* PF061793 */
     END; /* ELSE */
   END; /* DO WHILE */

 RETURN(W);

 END PARSE;
                                                         /* PF061793 */
 /*-------------------------------*/                     /* PF061793 */
 /* PROCESS MONTH NAME            */                     /* PF061793 */
 /*-------------------------------*/                     /* PF061793 */
                                                         /* PF061793 */
 PROC_MONTH: PROC(M,Y);                                  /* PF061793 */
                                                         /* PF061793 */