*DECK,CLM 
***  CLM - CCC LOADER AND MONITOR 
***  1.0  IDENTIFICATION
**
*    1.1  PROGRAM NAME
* 
*         CLM - CCC LOADER AND MONITOR
* 
*    1.2  AUTHORS 
* 
*         C.J. COPPICUS    OCTOBER 1, 1980
* 
*    1.3  AUTHORS OF MODIFICATIONS
* 
*         D.H. WIESE       DECEMBER 1, 1984 
* 
*    01/30/85                CHANGES TO CORRECT MISCELLANEOUS DOC-
*                            UMENTATION ERRORS AND ADD  ADDITIONAL
*                            EXPLANATIONS AS DEEMED NECESSARY.
*    04/23/85                CHANGES TO ALLOW A STATUS OF 0000 (CW
*                            INTACT) OR 5403B (CW CHECKSUM ERROR),
*                            FOLLOWING THE INVOKING OF THE IN-LINE
*                            DIAGNOSTICS. 
*    06/14/85                THIS CHANGE ADDS A  MODULE TO  CLM TO
*                            INVOKE  THE DATA CHECK TEST (O4 FUNC-
*                            TION) IN  THE MASSTOR  SUBSYSTEM CON-
*                            TROLWARE.
*    07/17/87                REMOVES THE PARAMETER 1 CHECK SO THAT
*                            THE MODEL B CCC,  WITH 64K MEMORY CAN
*                            BE TESTED. 
*    1.4  COPYRIGHT 
* 
*                   COPYRIGHT CONTROL DATA 1984 
*                        ALL RIGHTS RESERVED
*         CONTAINED HEREIN ARE SOFTWARE PRODUCTS COPYRIGHTED
*         BY CONTROL DATA CORPORATION.  REPRODUCTION WITHOUT
*         PERMISSION IS PROHIBITED.  THE COPYRIGHT NOTICE MUST
*         APPEAR ON ALL AUTHORIZED COMPLETE OR PARTIAL COPIES.
* 
* 
***  2.0  INTRODUCTION
**
*    2.1  OVERVIEW
* 
*         CLM IS THE CYBER CHANNEL COUPLER LOADER AND MONITOR.
*         CLM WILL LOAD, START EXECUTION, AND MONITOR A CCC TEST. 
* 
*    2.2  CHARACTERISTICS 
* 
*         1.  PROGRAM NAME ..........................   CLM 
*         2.  TEST/DIAG/UTILITY/SYSTEM ..............   UTILITY 
*         3.  SIZE (SOURCE) .........................   N/A 
*         4.  SIZE (MEMORY REQUIRED FOR EXECUTION)...   N/A 
*         5.  VIRTUAL CODE/MICROCODE/PP CODE/OTHER...   PP CODE 
*         6.  RUN TIME (DEFAULT) ....................   N/A 
*         7.  RUN TIME/QUICK LOOK (DEFAULT)..........   N/A 
*         8.  RUN TIME (ALL OPTIONS/SECTIONS) .......   N/A 
*         9.  LEVEL OF ISOLATION ....................   NONE
*         10. ON-LINE/OFF-LINE/BOTH .................   BOTH
*         11. ON-LINE SYSTEM ........................   NOS 
*         12. OFF-LINE SYSTEM .......................   CMSE
*         13. RESIDENT DURING EXECUTION .............   PP
*         14. ASSEMBLY LANGUAGE .....................   MALET 
*         15. SOURCE CODE MAINTENANCE ...............   UPDATE
*         16. USES MAINTENANCE CHANNEL ..............   NO
* 
*    2.3  FEATURES
* 
*         CLM IS A CCC TEST LOADER AND MONITOR, AND THEREFORE DOES
*         NOT PERFORM ANY TESTING ON ITS OWN.  IT WILL HOWEVER IN-
*         VOKE  THE CCC IN-LINE  DIAGNOSTICS  PRIOR TO LOADING ANY
*         TEST, AND REPORT THE RESULTS IF AN ERROR OCCURS. IT WILL
*         ALSO REPORT ANY ERROR DETECTED AS A RESULT OF LOADING OR
*         EXECUTING A TEST. 
* 
*         THE CURRENT VERSION WILL RUN ON NIP, MASSTOR AND 895. 
* 
*         CLM MODULE 20 INVOKES THE DATA CHECK TEST WITHIN THE
*         CCC MASSTOR CONTROLWARE.
* 
*         CLM MODULE 30 AUTOLOADS CONTROLWARE TO THE CYBER CHANNEL
*         COUPLER FROM THE MALET SCRATCH FILE.
* 
*    2.4  HARDWARE REQUIREMENTS 
* 
*         1. CONTROL DATA 6000, CYBER 70, OR CYBER 170/180 WITH 
*            NOS OPERATING SYSTEM.
* 
*         2. CYBER CHANNEL COUPLER. 
* 
*    2.5  RESTRICTIONS
* 
*         ANY CCC TEST WRITTEN ONTO THE SYSTEM *SCRATCH* FILE MUST
*         CONTAIN A 77 AND 6PPM OR 52 TABLES. 
*         THE 77 TABLE CONTAINS THE LENGTH OF THE 
*         CCC TEST AND IS USED BY THE CLM LOADER.  THIS TABLE, HOWEVER, 
*         IS NOT DOWNLOADED INTO THE CCC WITH THE TEST. 
* 
*         THE CCC DIAGNOSTIC MUST BE CONTAINED ON THE SYSTEM FILE 
*         CALLED  *SCRATCH* BEFORE A RUN COMMAND IS GIVEN TO CLM. 
* 
*         THE TEST PARAMETERS MUST BE ENTERED BEFORE THE CLM LOADER IS
*         RUN OR THE CCC TEST WILL RUN UNDER DEFAULT PARAMETERS.
* 
*         MODULE CLM20 REQUIRES THAT MASSTOR CONTROLWARE BE LOADED
*         AND RUNNING IN THE CCC. 
* 
* 
***  3.0  APPLICABLE DOCUMENTS
**
* 
*         CYBER CHANNEL COUPLER ENGR SPEC.                 53542416 
*         CYBER CHANNEL COUPLER CONTROLWARE SPEC.          53371093 
*         MALET REFERENCE MANUAL                           60456020 
*         CML REFERENCE MANUAL                             60455980 
*         MSL 150 REFERENCE MANUAL                         60456530 
*         MALET CODING STANDARD                            ARH5000
* 
* 
***  4.0  DESIGN OVERVIEW 
**
*    4.1  MODULES OVERVIEW
* 
*         CLM IS DIVIDED INTO FOUR BASIC PARTS. THE FIRST PART IS FOR 
*         PARAMETER CHECKING (MODULE CLM00). THE SECOND LOADS THE 
*         TEST TO BE RUN (MODULES CLM01-01C), AND THE THIRD MONITORS
*         THE RUNNING TEST (MODULES CLM02-02F).  THE LAST PART OF CLM 
*         CONSISTS OF A SINGLE MODULE, CLM20. THIS MODULE INVOKES THE 
*         DATA CHECK TEST WITHIN THE MASSTOR CONTROLWARE. 
* 
*         IF A CCC IS TO BE TESTED, CALLING CLM WILL CAUSE CLM00
*         TO EXECUTE FIRST, CHECKING THE PARAMETER ENTRIES. 
* 
*                                                   ACCESS      RUN 
*         MODULE     DESCRIPTION                    LEVEL       TIME
*         ------     -----------                    ------      ----
*         CLM00      PARAMETER CHECKER                10        1 SEC.
* 
*         CLM01 LOADS AND THEN VERIFYS THE LOAD OF A CCC RESIDENT TEST. 
*         CLM01 WILL FUNCTION A ZERO LENGTH AUTOLOAD(0414). THIS CAUSES 
*         THE CCC TO EXECUTE ITS INTERNAL IN-LINE DIAGNOSTICS.  THE 
*         STATUS WILL BE CHECKED TO DETERMINE IF THE IN-LINES EXE-
*         CUTED PROPERLY, IF NOT THE ERROR CODE WILL BE REPORTED. 
*         CLM01 WILL ALSO CHECK THE STATUS OF THE CCC FOLLOWING THE 
*         PMC (0740) FUNCTION TO DETERMINE IF THE PROCESSOR IS IN A 
*         MC STATE.  IF NOT, THE ERROR IS REPORTED AND CLM01 WILL 
*         PAUSE AWAITING OPERATOR ACTION. 
* 
*                                                   ACCESS      RUN 
*         MODULE     DESCRIPTION                    LEVEL       TIME
*         ------     -----------                    ------      ----
*         CLM01      CCC TEST LOADER                  10      +VARIES 
*         CLM01A     CALCULATE TEST LENGTH            10        1 SEC.
*         CLM01B     CHECK 4-F AFTER PMC/REPORT ERROR 10        1 SEC.
*         CLM01C     INVOLKE THE IN-LINE DIAGS        10        1 SEC.* 
*         + DEPENDS UPON THE LENGTH OF THE TEST BEING LOADED. 
* 
*         CLM02 WILL START THE CCC PROCESSOR AND CONTINUE TO MONITOR
*         THE EXECUTION OF THE CCC TEST.  CLM02 WILL CONTINUE IN ITS
*         MONITOR LOOP UNTIL THE TEST TERMINATES. 
* 
*                                                   ACCESS      RUN 
*         MODULE     DESCRIPTION                    LEVEL       TIME
*         ------     -----------                    ------      ----
*         CLM02      CCC TEST MONITOR                 10      +VARIES 
*         CLM02A     TEST PARAMETER SUBMODULE         10        1 SEC.
*         CLM02B     TEST STOP SUBMODULE              10        1 SEC.
*         CLM02C     TEST STATUS SUBMODULE            10        1 SEC.
*         CLM02E     TEST ERROR SUBMODULE             10        1 SEC.
*         CLM02F     HARDWARE ERROR DISPLAY SUBMODULE 10        1 SEC.
* 
*         MODULE CLM20 IS A STANDALONE MODULE AND MUST BE EXECUTED
*         AS SUCH VIA A MALET RUN CLM(20) COMMAND.
*         CLM20 CHECKS FOR RUNNING CONTROLWARE IN THE CCC. IF IT IS 
*         RUNNING THE DATA CHECK TEST IS INVOKED VIA AN 04 FUNCTION.
*         THE RESULTS ARE MONITORED AND ANY RESULTING ERROR DISPLAYED.
*         ****THIS MODULE REQUIRES ABOUT 120 SECONDS TO EXECUTE.****
*         ***********IF THE DEVICE CODE IS 105 MASSTOR CSS**********
*         ****THIS MODULE REQUIRES ABOUT 220 SECONDS TO EXECUTE.****
* 
*                                                   ACCESS      RUN 
*         MODULE     DESCRIPTION                    LEVEL       TIME
*         ------     -----------                    ------      ----
*         CLM20      INVOKE DATA TEST(MASSTOR DC 104) 10      120 SEC.
*         CLM20      INVOKE DATA TEST(MASSTOR DC 105) 10      220 SEC.
* 
*         MODULE CLM30 IS A STANDALONE MODULE AND MUST BE EXECUTED
*         AS SUCH VIA A MALET RUN CLM(30) DIRECTIVE.
*         CLM MODULE 30 AUTOLOADS CONTROLWARE TO THE CYBER CHANNEL
*         COUPLER FROM THE MALET SCRATCH FILE TESTS FOR GENERAL 
*         STATUS EQUAL ZERO AND NO CHANNEL PARITY ERROR STATUS FROM 
*         THE CCC.
* 
*                                                   ACCESS      RUN 
*         MODULE     DESCRIPTION                    LEVEL       TIME
*         ------     -----------                    ------      ----
*         CLM30      AUTOLOAD CONTROLWARE TO CCC      10        7 SEC.
* 
*         MODULE CLM31 IS A STANDALONE MODULE AND MUST BE EXECUTED
*         AS SUCH VIA A MALETVE RUN CLM(31) DIRECTIVE.
*         CLM MODULE 31 READS CCC MEMORY AND PRINTS THE DATA. 
* 
*         MODULE       DESCRIPTION            LEVEL           TIME
*         ------       -----------            ------          ----
*         CLM31        CCC MEMORY DUMP          10           - SEC
* 
*    4.2  EXECUTION SEQUENCE
* 
*         UPON ENTERING THE RUN CLM COMMAND, THE PARAMETER CHECK MODULE 
*         (CLM00) WILL SCAN THE PARAMETERS THAT THE USER KEYED IN AND 
*         WILL INFORM THE USER OF ANY ILLEGAL ENTRIES BEFORE DOWNLOAD-
*         LOADING THE TEST. 
* 
*         THE LOCAL LOADER LOADS A CCC DIAGNOSTIC FROM THE SYSTEM 
*         *SCRATCH* FILE INTO THE LOCAL CCC MEMORY BEGINNING AT ADDRESS 
*         0.  THE LOAD IS THEN CHECKED WITH A ONE-WORD VERIFY.
* 
*         BEFORE THE LOAD PROCESS ACTUALLY BEGINS, THE LENGTH OF THE
*         TEST IS CALCULATED IN ORDER TO SET UP THE ADDRESS AND LENGTH
*         REGISTERS IN THE CCC.  IN ADDITION, A VERIFY IS DONE TO 
*         INSURE THAT THE CCC TEST IS PRESENT ON THE SYSTEM FILE
*         *SCRATCH*.  FINALLY, THE CCC PROCESSOR IS STOPPED AND 
*         THE LOADING PROCESS BEGINS.  WHEN AN END-OF-RECORD IS DETECT- 
*         ED ON THE *SCRATCH* FILE, THE LOAD IS COMPLETE.  NOW A ONE- 
*         WORD VERIFY PROCESS IS DONE TO INSURE THAT THE CCC TEST WAS 
*         WRITTEN INTO THE CCC MEMORY CORRECTLY.
* 
*         THE CYBER CHANNEL IS RESERVED WHILE THE CCC TEST IS BEING 
*         DOWNLOADED INTO THE CCC.  THE CHANNEL IS THEN RELEASED
*         BY THE PP WHEN AN END-OF-RECORD IS DETECTED IN THE *SCRATCH*
*         FILE. 
* 
*         THE USER WILL BE KEPT INFORMED OF HOW THE LOAD IS PROCEED-
*         ING VIA NORMAL MESSAGES SENT THE THE KL AND OUTPUT FILE.
* 
*         THE MONITOR STARTS THE CCC DIAGNOSTIC EXECUTING.  THE 
*         MONITOR THEN WATCHES THE CCC MEMORY LOCATIONS CONTAINING THE
*         TEST STATUS (COMMON CCC MEMORY).  ALL CHANGES IN THE TEST 
*         STATUS WILL BE SEEN BY THE MONITOR AND THE MONITOR WILL 
*         INFORM THE USER VIA THE KL DISPLAY, TERMINAL DISPLAY OR 
*         THE PRINT FILE.  THE USER CAN DIRECT THE COURSE OF THE
*         TEST WHILE IT IS RUNNING BY CHANGING THE EXECUTIVE SWITCHES.
*         THE MONITOR WILL FREQUENTLY DOWNLOAD THE EXECUTIVE SWITCHES 
*         INTO THE COMMON CCC MEMORY WHICH WILL BE SENSED BY THE TEST.
* 
*         ALL ERRORS OCCURRING DURING TEST EXECUTION DUE TO EITHER I/O
*         PROBLEMS, OR HARDWARE PROBLEMS DETECTED BY THE TEST WILL
*         CAUSE THE TEST AND THE MONITOR TO STOP AND REPORT THE ERROR.
*         DEPENDING ON THE TYPE OF ERROR, THE USER MAY OR MAY NOT 
*         BE ABLE TO CONTINUE TEST EXECUTION. 
* 
***  5.0  PARAMETERS
**
*    5.1  PARAMETER REGISTER DEFINITIONS AND IMPORTANT LOCATIONS IN 
*         THE CCC MEMORY. 
* 
*         ADDRESS (HEX)       CONTENTS (HEX)
*         -------------       --------------
*         0040               NOT USED 
* 
*         0041               DIAGNOSTIC SWITCHES
* 
*                            XXX1 - STOP ON ERROR 
*                            XXX2 - REPEAT MODULE 
*                            XXX4 - REPEAT CONDITION
*                            XX1X - STOP AT BEGINNING OF CONDITION
*                            XX2X - STOP AT BEGINNING OF MODULE 
*                            XX4X - STOP AT BEGINNING OF TEST 
*                            X1XX - STOP END OF TEST
*                            X2XX - STOP END OF CONDITION 
*                            X4XX - END OF MODULE 
*                            1XXX - PROGRAMABLE SWITCH(R10) 
*                            2XXX - REPEAT TEST 
*                            4XXX - PROGRAMMABLE SWITCH(R11)
* 
*         0042               FUNCTION TO DIAGNOSTIC PROGRAM 
* 
*                            0000 - RESERVED
*                            0002 - CONTINUE TEST EXECUTION 
*                            0006 - ACKNOWLEDGE INDICATOR - 
*                                   USED BY NDI/MONITOR TO
*                                   COMMUNICATE PARAMETER 
*                                   CHANGES WHILE RUNNING 
*                                   CCC TEST. 
* 
*         0043                NOT USED
* 
*         0044               DEVICE TYPE
* 
*                            0001  -  CCC DEVICE
*                            0002  -  NAD DEVICE
* 
*         0045                NOT USED
* 
*                            P0 - NOT USED BY CLM, BUT PASSED TO THE CCC
* 
*         0047               P1 - MEMORY SIZE 
* 
*                            LEGAL PARAMETERS ARE-
*         0000 THROUGH 0007 (DEFAULT = 0, 16K)
* 
*         0048               P2 - NOT USED BY CLM, BUT PASSED TO THE CCC
* 
*         0049               P3 - NOT USED BY CLM, BUT PASSED TO THE CCC
* 
*         004A               P4 - DISABLES
*                            XXX1 - DISABLE ERROR MESSAGE POSTING 
* 
*         004B               P5 - FIRST MODULE TO BE RUN IN THE SERIES
* 
*                            0000=MODULE 0 (DEFAULT)
*                            0001=MODULE 1
*                            0002=MODULE 2
*                            0003=MODULE 3
*                            0004=MODULE 4
*                            0005=MODULE 5
*                            0006=MODULE 6
*                            0007=MODULE 7
*                            ETC
* 
*         004C               P6 - TOTAL NUMBER OF MODULES TO BE RUN 
* 
*                            0000= ALL MODULES (DEFAULT)
* 
*         004D               P7 - NOT USED BY CLM, BUT PASSED TO THE CCC
* 
*         004E               P8 - NOT USED BY CLM, BUT PASSED TO THE CCC
* 
*         004F               P9 - NOT USED BY CLM, BUT PASSED TO THE CCC
* 
*         ADDRESS (HEX)       CONTENTS (HEX)
*         -------------       --------------
* 
*         0050               STATE
* 
*                            0000 - RESERVED
*                            0001 - STOPPED ON ERROR
*                            0002 - STOPPED AT BEGINNING OF TEST
*                            0003 - STOPPED AT BEGINNING OF MODULE
*                            0004 - STOPPED AT BEGINNING OF CONDITION 
*                            0005 - STOPPED AT END OF TEST
*                            0006 - STOPPED AT END OF MODULE
*                            0007 - STOPPED AT END OF CONDITION 
*                            0008 - STOPPED AT BREAKPOINT ADDRESS 
*                            0009 - STOPPED AT NOOP 
*                            000A - STOPPED WAITING FOR USER
*                                   INTERVENTION
*                            000B - STOPPED AT REQUEST OF USER
*                            000C - STOPPED WAITING FOR CONTINUE
*                            000D - TERMINATED (HUNG) 
*                            000E - STOPPED ON UNEXPECTED INTERRUPT 
*                            000F - EXECUTING 
* 
*         0051               NOT USED 
* 
*         0052               TEST NAME
* 
*                            AABB - AA IS RESERVED
*                                 - BB= FIRST 2 CHARACTERS OF THE TEST
*                                       NAME. 
* 
*                                   CYBER 17X USES DISPLAY CODE.
*                                   CYBER 20X USES ASCII CODE.
* 
*         0052               TEST NAME
* 
*                            CCDD - CC IS RESERVED
*                                 - DD= LAST 2 CHARACTERS OF THE TEST 
*                                       NAME. 
* 
*                                   CYBER 17X USES DISPLAY CODE.
*                                   CYBER 20X USES ASCII CODE.
* 
*         0053               TEST NAME
* 
*                            CCDD - CC IS THE SECOND CHARACTER OF THE 
*                                   TEST NAME.  DD IS THE THIRD CHAR- 
*                                   ACTER OF THE TEST NAME.  (BOTH ARE
*                                   IN DISPLAY CODE FOR CYBER 17X AND 
*                                   IN ASCII FOR THE CYBER 20X.)
* 
*         0054               REVISION LEVEL OF THE DIAGNOSTIC 
* 
*         0055               ASSEMBLY DATE
* 
*                            FEXX - YEAR
*                            X1EX - MONTH 
*                            XX1F - DAY 
* 
*         0056               ASSEMBLY TIME
* 
*                            X7CX - HOUR
*                            XX3F - MINUTE
* 
*         0057               MODULE AND CONDITION NUMBER
* 
*                            MMCC - MM IS THE MODULE NUMBER.
*                                   CC IS THE CONDITION NUMBER. 
* 
*         0058               ERROR CODE 
* 
*         0059               ERROR COUNT
* 
*         005A               PASS COUNT 
* 
*                            PASS COUNT IS DEFINED AS THE NUMBER OF 
*                            TIMES THROUGH THE PORTION OF THE CODE
*                            BEING REPEATED BY THE DIAGNOSTIC SWITCHES
*                            (RT,RM OR RC). IT IS NOT TO BE CONFUSED
*                            WITH THE ITERATION COUNT WHICH IS
*                            PROGRAM-DEFINED. 
* 
*         005B               P ADDRESS OF THE LAST CALL MADE BY THE 
*                            TEST TO NDI
* 
*         005C               FIXED VALUE (F501) 
* 
*         005D               CURRENT ADDRESS BEING TESTED 
* 
*         005E               EXPECTED VALUE 
* 
*         005F               ACTUAL VALUE 
* 
*         0060               ITERATION COUNT
* 
*                            THIS IS USED BY THE DIAGNOSTIC PROGRAMMER
*                            TO REPORT THE NUMBER OF TIMES THROUGH
*                            VARIOUS LOOPS DESIGNED INTO THE TEST CODE
*                            ITSELF.
* 
*         0061               LAST WORD ADDRESS
* 
*                            THIS STATUS CONTAINS THE ADDRESS OF THE
*                            LAST WORD ASSEMBLED AS PART OF THE 
*                            DIAGNOSTIC.
* 
*         MESSAGE BUFFER
* 
*         0070               CHARACTERS 00,01 OF THE ERROR MESSAGE
* 
*         0071-7D            CHARACTERS 02,27 OF THE ERROR MESSAGE
* 
*    5.2  PARAMETER REGISTER USAGE
* 
*         MODULE    P1  P2  P3  P4  P5  P6  P7  P8  P9
*         ------    --  --  --  --  --  --  --  --  --
*         CLM00     X               X   X 
*         CLM01 
*         CLM02     X   X   X   X   X   X   X   X   X 
*         CLM31                         X   X   X   X 
* 
***6.0    PROGRAM USE 
**
*         BECAUSE CLM IS A LOADER AND MONITOR PROGRAM, AND THEREFORE
*         DOES ONLY A VERY MINIMUM OF TESTING, THE FOLLOWING INFOR- 
*         MATION IS INCLUDED ONLY TO ASSIST IN LOADING IT.
* 
*    6.1  LOADING PROCEDURE 
* 
*         ATTACH(GET),CLM.                 ATTACH(GET),RFILE=CLM. 
*         ATTACH(GET),NDP,(NDM).    OR     ATTACH(GET),NDP,(NDM). 
*         MALET,R=CLM,KL.                  MALET,KL.
* 
*    6.2  RUNNING PROCEDURE 
* 
*         A.  TO ASSIGN CCC EQUIPMENT TO CLM
* 
*                A,EST=XXX,AL=10. 
*            OR  A,CH=XX,EQ=0,UN=0,EST=NO,DC=XX,AL=10.
* 
*              USE CHANNEL ASSIGNMENT IF EQUIPMENT IS NOT IN EST. 
* 
*         B.  SET SCRATCH FILE EQUAL TO TEST TO BE RUN OR THE 
*             CONTROLWARE FILE TO BE LOADED.
* 
*                SCRATCH=XXX     XXX=NDP(PROC.TEST)OR NDM(MEMORY TEST)
*                SCRATCH=XXX     XXX=CONTROLWARE FILE NAME
* 
*         C. TO LOAD AND RUN ONE PASS OF A CCC TEST IN THE CCC
*            UNDER DEFAULT PARAMETERS.
* 
*                R CLM
* 
*         D.  TO LOAD AND RUN ONE PASS OF A CCC TEST IN THE CCC 
*             UNDER SELECTED PARAMETERS.
* 
*                P,P....... 
*                SETSW,CLRSW.....           EXECUTIVE SWITCHES
*                SETDS,CLRDS.....           DIAGNOSTIC SWITCHES 
*                R CLM
* 
*         E. TO REPEAT A MODULE OR SERIES OF MODULES IN THE CCC TEST
* 
*                P,P5=XXXX,P6=XXXX      SELECT THE MODULES TO RUN 
*                SETSW,RT               SET REPEAT TEST 
*                R CLM                  RUN IN CCC
* 
*         F. IF THE TEST TERMINATES, THE CCC TEST MUST BE RELOADED
*            BY USING THE RUN COMMAND, IN ORDER TO RUN AGAIN. 
* 
*         G. TO MAKE A PARAMETER REGISTER CHANGE WHILE THE TEST IS IN 
*            PROGRESS.
* 
*                STOP                   STOP THE TEST 
*                P,P.....               MAKE PARAMETER CHANGE 
*                R CLM02                CONTINUE TESTING CCC
* 
*                NOTE_ THESE PARAMETER CHANGES WILL ONLY EFFECT THE 
*                      THE REMAINDER OF THE TEST UNLESS RT IS SET.
* 
*         H. TO CHANGE A SWITCH IN THE EXECUTIVE REGISTER.
* 
*                STOP                   STOP THE TEST 
*                SETSW,....             SET A SWITCH IN THE ES REGISTER 
*             OR CLRSW,....          OR CLEAR A SWITCH IN THE ES REG. 
*                GO                     CONTINUE THE TEST 
* 
***  7.0  MESSAGES
**
*    7.1  NORMAL MESSAGES 
* 
*         CLM00 - PARAMETER CHECKER 
* 
*               - INDICATES THAT THE CONTENTS OF THE PARAMETER
*                 REGISTERS ARE BEING CHECKED FOR VALID CONTENTS. 
* 
*         CLM01 - CCC LOADER
*               - INDICATES THAT A CCC TEST IS BEING LOADED INTO
*                 THE CCC MEMORY
* 
*         TTT  LOADING
*               - TTT IS THE NAME OF THE CCC TEST LOADING.
*               - INDICATES THAT A CCC TEST IS BEING DOWNLOADED INTO
*                 THE CCC MEMORY. 
* 
*         TTT  LOADED 
*               - TTT IS THE NAME OF THE CCC TEST LOADED. 
*               - INDICATES THAT A CCC TEST WAS SUCCESSFULLY LOADED 
*                 INTO THE CCC. 
* 
*         TTT  LOAD CONFIRMED 
*               - TTT IS THE NAME OF THE CCC TEST.
*               - INDICATES THAT THE CCC TEST LOAD VERIFIED.
* 
*         CALCULATING LENGTH OF TTT 
*               - TTT IS THE NAME OF THE CCC TEST.
*               - INDICATES THAT THE NUMBER OF CCC WORDS IN THE TEST
*                 IS BEING CALCULATED.
* 
*         CLM20 - MASSSTOR DATA CHECK 
*               - INDICATES THAT THE 04 FUNCTION IS BEING CHECKED IN
*                 THE MASSTOR CCC CONTROLWARE.
* 
*         CLM30 - CCC AUTOLOADER
* 
*         AUTOLOADING DD BLOCKS OF MHHHH TO CCC 
*               - DD IS THE NUMBER OF DECIMAL 500B PP WORD BLOCKS.
*               - MHHHH IS THE NAME OF THE CONTROLWARE. 
* 
*         MHHHH REV RR CONTROLWARE AUTOLOADED TO CCC
*               - MHHHH IS THE NAME OF THE CONTROLWARE. 
*               - RR IS THE CONTROLWARE REVISION LEVEL. 
* 
*         CLM30 READING DD BLOCKS OF MHHHH REV RR 
*               - DD IS THE NUMBER OF DECIMAL 500B PP WORD BLOCKS.
*               - MHHHH IS THE NAME OF THE CONTROLWARE. 
*               - RR IS THE CONTROLWARE REVISION LEVEL. 
* 
*         CLM31-CCC MEMORY DUMP ROUTINE 
*               WHERE YYYY IS THE HEX VALUE OF THE ADDRESS. 
*               WHERE XXXX IS THE HEX DATA FROM CCC MEMORY. 
* 
*                YYYY  YYYY  YYYY  YYYY 
*                ----  ----  ----  ---- 
*                XXXX  XXXX  XXXX  XXXX 
* 
*    7.2  ERROR FORMAT
* 
*         CCC LOADER AND MONITOR (CLM)
*         *A*A*D   EC=DECD   LC=DECD
*         MOD=*DD   COND=*DD   PCNT=*DECD 
*         LAST CALL TO NDI FROM ADDRESS *H*H H
*         ADDR=*H*H H 
*                     ECNT=DECD       ICNT=DECD 
*         *A*A*D EXECUTING
* 
*         WHERE:  
*              *A*A*D = NAME OF CCC TEST RUNNING IN THE CCC 
*              EC = ERROR COUNT WHEN SCOPE LOOPING
*              LC = LOOP COUNT WHEN SCOPE LOOPING 
*              MOD=*DD = MODULE OF CCC TEST PRESENTLY RUNNING 
*              COND=*DD = CONDITION OF CCC TEST PRESENTLY RUNNING 
*              PCNT=*DECD = PASS COUNT OF CCC TEST
*              ADDRESS *H*H H = LAST NDI ADDRESS CALLED BY CCC TEST 
*              *A*A*D = TEST NAME / MODULE RUNNING IN CCC.
* 
*    7.3  ERROR MESSAGES
* 
*         TWO TYPES OF ERRORS ARE POSSIBLE.  FIRST ARE ERRORS DETECTED
*         BY CLM.  THESE COULD BE CHANNEL PROBLEMS, NO TEST ON SCRATCH
*         FILE, PARAMETER PROBLEMS. 
* 
*         THE SECOND TYPE OF ERROR WOULD BE ERRORS DETECTED BY THE TEST 
*         CLM LOADED AND STARTED EXECUTING. 
* 
*         IN EITHER CASE ERRORS WILL BE REPORTED TO USER BY WAY OF
*         DAYFILE MESSAGES OR KL DISPLAY, OR OUTPUT FILE. 
* 
*         ERROR CODES 
*         ----------- 
* 
*         E0002 - CHANNEL PARITY ERROR
*               - THE CHANNEL DETECTED A PARITY ERROR WHILE DATA
*                 WAS BEING TRANSFERRED ACROSS THE CYBER CHANNEL. 
* 
*         E0003 - TEST LOADED INCORRECTLY 
*               - THE ONE-WORD VERIFY PROCESS FAILED AND INDICATES
*                 THAT THE COMPLETE TEST DOES NOT RESIDE IN CCC 
*                 MEMORY. 
* 
*         E0004 - TEST NOT IN SYSTEM FILE 
*               - BEFORE THE TEST IS DOWNLOADED TO THE CCC, THE 
*                 LOADER CHECKS TO SEE IF THE CCC TEST WAS WRITTEN
*                 INTO THE SYSTEM *SCRATCH* FILE BY LOOKING FOR THE 
*                 77 HEADER TABLE.  IF THE 77 HEADER TABLE CANT BE
*                 FOUND, THIS ERROR MESSAGE IS RECEIVED.
* 
*         E0005 - IN-LINE DIAG ERROR
*               - PRIOR TO DOWNLOADING A TEST INTO THE CCC, THE IN- 
*                 LINE DIAGNOSTICS WERE STARTED. IF THE DIAGNOSTICS 
*                 COMPLETE PROPERLY, BUT THE GENERAL STATUS RETURN- 
*                 DOES NOT EQUAL 0000 OR 5403B, THIS MSG IS GENERATED.
* 
*         E0006 - ABNORMAL GENERAL STATUS 
*               - AFTER THE CONTROLWARE HAS BEEN AUTOLOADED TO THE CCC
*                 THE GENERAL STATUS RETURNED WAS NOT EQUAL TO EXPECTED.
*                 THE ACTUAL GENERAL STATUS RETURNED AND THE EXPECTED 
*                 GENERAL STATUS ARE ALSO POSTED. MODULE CLM30 ONLY.
* 
*         E0007 - SCRATCH FILE EMPTY OR MISSING 
*               - PRIOR TO AUTOLOADING THE CONTROLWARE TO THE CCC THE 
*                 SCRATCH FILE IS READ AND IF EOI IS ENCOUNTERED ON THE 
*                 FIRST READ THIS MESSAGE IS POSTED. MODULE CLM30 ONLY. 
* 
* 
*         CCC LOADER AND MONITOR (CLM)
*         DIAGNOSTIC *A*A   REVISION *OB
*         ASSEMBLED ON DD/MM/YY  AT HH/MM/SS
*         *A*A*D   EC=DECD   LC=DECD
*         MOD=*DD   COND=*DD   PCNT=*DECD 
*         LAST CALL TO NDI FROM ADDRESS *H*H H
*         *A*A*D  STOPPED ON ERROR
*         ERROR MESSAGE 
*         ERROR MESSAGE(CONTINUED)
*         ADDR=*H*H H 
*                     ECNT=DECD       ICNT=DECD 
* 
*         WHERE:  
*              *A*A = NAME OF CCC TEST EXECUTING
*              REVISION *OB = REVISION
*              *A*A*D = NAME OF CCC TEST RUNNING IN THE CCC 
*              EC = ERROR COUNT WHEN SCOPE LOOPING
*              LC = LOOP COUNT WHEN SCOPE LOOPING 
*              MOD=*DD = MODULE OF CCC TEST PRESENTLY RUNNING 
*              COND=*DD = CONDITION OF CCC TEST PRESENTLY RUNNING 
*              PCNT=*DECD = PASS COUNT OF CCC TEST
*              ADDRESS *H*H H = LAST NDI ADDRESS CALLED BY CCC TEST 
* 
* 
*         CLM00 - PARAMETER ERROR DETECTED
* 
*         PROCESSOR ERROR ON MASTER CLEAR 
*               - A COMPARE ERROR WAS DETECTED WHEN CCC MEMORY
*                 LOCATIONS 4-F WERE READ.  THIS INDICATES THAT 
*                 AN ERROR OCCURRED DURING THE MASTER CLEAR 
*                 PROCESS.  THE USER CAN CONTINUE AT OWN
*                 RISK. 
* 
*         CONTENTS OF LOCATIONS 4-F 
*               - THE CONTENTS OF CCC MEMORY WORDS 4-F ARE DISPLAYED
*                 IF A PROCESSOR MASTER CLEAR ERROR OCCURRED. 
* 
*         TTTMM STOPPED ON ERROR
*               - TTTMM IS THE NAME OF THE TEST/MODULE THAT STOPPED.
*               - INDICATES THAT AN ERROR OCCURRED AND THE TEST HAS 
*                 STOPPED.
* 
*         ERROR MMMMMMMMMMMMMMMMMMMM
*               - TEST HAS STOPPED DUE TO AN ERROR DETECTED BY THE TEST.
*                 MMMM....M IS THE TEST ERROR MESSAGE.
* 
*         EC=EEEE       ECNT=CCCC         ICNT=IIII 
*               - EEEE = ERROR CODE 
*               - CCCC = ERROR COUNT
*               - IIII = ITERATION COUNT
* 
*         ADDR=AAAA      EXP=EEEE      ACT=RRRR 
*               - AAAA = CCC ADDRESS WHERE FAILURE OCCURRED.
*               - EEEE = EXPECTED CONTENTS OF THE FAILING ADDRESS.
*               - RRRR = ACTUAL CONTENTS OF FAILING ADDRESS.
* 
*         HARDWARE STATUS=HHHH
*               - CCC HARDWARE STATUS.
* 
*         CCC ERROR CODE = *OCTB
*               - CCC GENERAL STATUS. 
* 
*         CCC IN-LINE FAILURE - NO
*          RESPONSE WITHIN 500MS
*               - THE IN-LINE DIAGNOSTICS WERE INVOLKED BY SENDING
*                 A ZERO LENGTH AUTOLOAD TO THE CCC.  NO RESPONSE 
*                 TO THE FUNCTION WAS RECEIVED WITHIN 500MS.  THIS
*                 INDICATES THAT THE CCC IS HUNG-UP.
* 
*         CLM20 - NO CNTRLWARE OR IN-LINE FAILURE 
*               - A CHECK WAS PERFORMED ON THE CCC TO DETERMINE IF THE
*                 MASSTOR CONTROLWARE WAS RUNNING PRIOR TO INVOKING 
*                 THE DATA CHECK TEST.  IT WAS FOUND NOT TO BE RUNNING
*                 OR IT WAS RUNNING BUT THE IN-LINE DIAGNOSTIC DETECT-
*                 ED AN ERROR.
* 
*         CLM20 - STATUS  ERROR = *OCTB *OCTB *OCTB 
*               - THE DATA CHECK WAS FUNCTIONED AND THE STATUS RETURNED 
*                 WAS INCORRECT.  THE 3 WORDS OF STATUS ARE DISPLAYED.
* 
*         CLM20 - MASSTOR PATH CHECK FAILURE(S)= *DECD
*               - THE DATA CHECK TEST FAILED. 
* 
*         CLM20 - ABORTED ON XXXXXX 
*          LAST FUNCTION = *OCTB
*               - DISPLAYED WHENEVER AN ABORT OCCURS AS THE RESULT OF 
*                 FUNCTION ON THE CHANNEL.  XXXXXX WILL EQUAL THE 
*                 COMMAND WHICH ABORTED.
* 
*         CLM20 - NO RESPONSE WITHIN 3 MIN. DC=104. 
*                -THE DATA CHECK REQUIRES UP TO A MAXIMUM OF 2.0
*                 MINUTES TO EXECUTE DEPENDING ON THE LEVEL OF M862SD 
*                 MICROCODE. IF IT HAS NOT COMPLETED IN 3 MINUTES,
*                 THIS MESSAGE IS DISPLAYED.
* 
*         CLM20 - NO RESPONSE WITHIN 5 MIN. DC=105. 
*                -THE DATA CHECK REQUIRES APPROX. 3.7 MINUTES TO EXE- 
*                 CUTE.  IF IT HAS NOT COMPLETED IN 5 MINUTES, THIS 
*                 MESSAGE IS DISPLAYED. 
* 
*         CLM20 - DATA CHECK TEST RUNNING *DE SEC 
*                -THIS MESSAGE IS DISPLAYED TO INFORM THE USER THAT 
*                 THE TEST IS CONTINUING TO RUN.
* 
*         CLEAR RM TO TERMINATE TEST
*               - THE REPEAT MODULE SWITCH MUST BE TURNED OFF BEFORE
*                 THE TEST IS TERMINATED.  THIS WILL PREVENT THE
*                 LOADER/MONITOR MODULES FROM REPEATING BECAUSE THE 
*                 REPEAT MODULE SWITCH WAS ACCIDENTALLY LEFT ON.
* 
*         ********************************************************
*         THE FOLLOWING INFORMATION CONCERNING CCC ERROR CODES WAS
*         OBTAINED FROM A TYPICAL 895  CONTROLWARE LISTING, AND IS
*         SUPPLIED FOR REFERENCE ONLY.  THESE CODES ARE SUBJECT TO
*         CHANGE. CONSULT A CONTROLWARE LISTING  FOR YOUR  SITE TO
*         DETERMINE THE CORRECT ERROR CODES.
*         CONSULT ONE OR  BOTH OF  THE FOLLOWING  MANUALS FOR MORE
*         INFORMATION ON THESE CODES. 
*                CCC HARDWARE MAINTENANCE REF. MANUAL     60459170
*                CCC SUBSYSTEM USERS GUIDE                60459190
*         ********************************************************
* 
*         **ERROR CODES FOR THE MAINT. PANEL DISP AND GENERAL STATUS**
*         NOTE: HARDWARE ERROR CODES ARE ADDED TO THE MAINT. PANEL
*         CODES AND THE GENERAL STATUS WHEN NORMAL END TO A SEQUENCE IS 
*         NOT SET.
*         EXAMPLE: 804X   5101,5117 ARE GENERATED BY REPLACING X WITH 
*                  HARDWARE ERROR CODE AND ADDING THE ERROR CODE TO 
*                  5100B.  FOR GENERAL STATUS RANGING 5101B TO 5127B. 
* 
*         MAINT   GENERAL 
*         PANEL   STATUS
*         (HEX)   (OCT)   ERROR DESCRIPTION 
* 
*         8000            START ROM RESIDENT DIAG.,COMMAND TEST FAILURE 
*         8001            MEMORY TEST FOR CYBER AND CHANNEL I/F FAILURE 
*         8002            ROM CHECKSUM FAILURE, LOC. 8000 TO 87FF 
*         8003            ROM CHECKSUM FAILURE, LOC. 8800 TO 8FFF 
*         8004            CYBER I/F INTERACTION TEST, FUNCTION TIME-OUT 
*         8005            CYBER I/F INTERACTION TEST, MEMORY P.E. 
*         8006            CYBER I/F INTERACTION TEST, CONTROL PKG P.E.
*         8007            CYBER I/F INTERACTION TEST, DATA MISCOMPARE 
*         8040    5100    EQUIPMENT SWITCHES NOT SET FOR ANY DEVICE 
*         805X  5121,5137 NO NORMAL END IN STATUS AFTER LOAD XFER REGS
*         806X  5141,5157 NO NORMAL END IN STATUS AFTER READ XFER REGS
*         8070    5160    TRANSFER REGISTER DATA MISCOMPARE.
*         807X  5161,5177 NORMAL END NOT SET AFTER DIAG. WRITE SEQUENCE 
*         8080    5200    FULL/EMPTY CNTR INCORRECT AFTER DIAG. WRITE 
*         80A0    5240    CCC ADDRESS INCORRECT AFTER DIAG. READ
*         808X  5201,5217 NORMAL END NOT SET AFTER READ BLOCK ID
*         8090    5220    BLOCK ID WRONG AFTER DIAG. WRITE
*         809X  5221,5237 NORMAL END NOT SET AFTER DIAG. READ 
*         80A8    5250    DIAGNOSTIC READ PATTERN INCORRECT 
*         80A9    5251    XFER REGISTER ERROR AFTER DIAG. READ
*         80AA    5252    BLOCK ID WRONG AFTER DIAG. READ 
*         80AB    5253    CCC I/F SEQUENCE DID NOT COMPLETE 
*         80AC    5254    DATA STREAM DIAGNOSTIC READ TIME-OUT
*         80BX  5261,5277 DATA STREAM DIAG. READ STATUS NOT NORMAL END
*         80C0    5300    DATA STREAM DIAG. READ BLOCK ID WRONG 
*         80AD    5255    DATA STREAM DIAG. WRITE TIME-OUT
*         80CX  5301,5317 DATA STREAM DIAG. WRITE STATUS NOT NORMAL END 
*         80D8    5330    DATA STREAM DIAG. WRITE BLOCK ID WRONG
* 
*         ERRORS FROM THE AUTOLOAD FROM PP
* 
*         8101    5401    SYSTEM RESET ERROR OCCURRED AFTER CHECKSUM
*         8102    5402    CYBER I/F STATUS ERROR DURING AUTOLOAD
*         8103    5403    RAM RESIDENT CHECKSUM ERROR AFTER AUTOLOAD
*         8104    5404    RAM MEMORY TEST ERROR BEFORE AUTOLOAD 
* 
*         ERRORS FROM THE AUTOLOAD FROM DEVICE ROUTINE
* 
*         8141    5501    TIME-OUT FROM DEVICE SEEK OR RECAL. SEQUENCE
*         8142    5502    RECAL. OR SEEK ERROR FROM DEVICE
*         8143    5503    SEEK ENDING STATUS ERROR
*         8144    5504    SEARCH ERROR
*         8145    5505    READ DATA ERROR 
*         8146    5506    RAM CHECKSUM ERROR
*         8147    5507    SYSTEM RESET SEQUENCE ERROR 
*         8148    5510    SEARCH/READ SEQUENCE TIME-OUT 
* 
*         8800    0000    ROM IDLE LOOP 
*         8810    0000    AUTOLOAD FROM PP STARTED
*         8820    0000    AUTOLOAD FROM DEVICE STARTED
*         8888    0000    AUTOLOAD COMPLETED, RAM RESIDENT
* 
*         HARDWARE ERROR CODES
* 
*        CODE     (2A)    ERROR CONDITION           OTHER 
* 
*         1       0101    WRITE PATH P.E. UPPER  (1F09, BIT 10 SET) 
*         2       0101    WRITE PATH P.E. LOWER  (1F09, BIT 02 SET) 
*         3       0102    MEMORY PARITY ERROR 
*         4       0108    BUS IN P.E. AND READ PATH P.E.
*         5       0104    READ PATH PARITY ERROR
*         6       0110    BUS OUT FAULT          (1F08, BIT 03 SET) 
*         7       0110    TAG OUT FAULT UPPER    (1F08, BIT 04 SET) 
*         8       0110    TAG OUT FAULT LOWER    (1F08, BIT 09 SET) 
*         9       0120    FLAG BIT DETECTED 
*         A       0140    MINIMUM BLOCK LENGTH NOT MET
*         B       0201    SELECT IN RECEIVED
*         C       0202    NO REQUEST IN ON POLL SEQUENCE
*         D       0204    DEVICE ADDRESS MISCOMPARE 
*         E       0208    TIMEOUT ON FIPS TRANSFER
*         F       XXXX    UNDETERMINED ERROR CODE 
* 
*    7.4  DAYFILE MESSAGES
* 
*         MESSAGES WILL BE ENTERED INTO THE SYSTEM DAYFILE ONLY 
*         IF THE MALET EXECUTIVE SWITCH IS ON.
* 
***  8.0  GLOSSARY
**
*    8.1  ABBREVIATIONS 
* 
*          CCC - CYBER CHANNEL COUPLER
*          CLM - CCC LOADER AND MONITOR 
*          MALET - MAINTENANCE APPLICATION LANGUAGE FOR 
*                  EQUIPMENT TESTING
*          ERS - EXTERNAL REFERENCE SPECIFICATION 
*          LCN - LOOSELY COUPLED NETWORK
*          NAD - NETWORK ACCESS DEVICE
*          NDI - NAD DEVICE INTERFACE ALSO USED IN CCC
*          NDP - NAD RESIDENT PROCESSOR TEST USED IN CCC
*          NDM - NAD RESIDENT MEMORY TEST USED IN CCC 
* 
*    8.2  MISCELLANEOUS 
* 
*         THE FOLLOWING DETAILED DESCRIPTION IS INCLUDED FOR GENERAL
*         INFORMATION.
* 
*         AFTER THE TEST IS LOADED AND VERIFIED, THE MONITOR WILL 
*         BEGIN EXECUTION.  THE FOLLOWING DESCRIBES THE MONITOR'S 
*         PROTOCOL. 
* 
*         1. START THE CCC PROCESSOR. CHECK IF THE PROCESSOR IS 
*            RUNNING.  IF IT IS RUNNING CONTINUE AT 2. IF THE 
*            PROCESSOR IS NOT RUNNING, THE PROCESSOR MAY HAVE 
*            A PROBLEM.  FOR THIS REASON MONITOR WILL PAUSE AND 
*            DISPLAY ADDRESS 4-F  OF CCC MEMORY.  THE 
*            HARDWARE STATUS WILL ALSO BE DISPLAYED.  IF THE
*            USER CHOOSES TO CONTINUE, HE MUST ENTER GO AND 
*            THE MONITOR WILL CONTINUE AT 2.
* 
*         2. INPUT CURRENT TEST STATUS FROM THE CCC.
* 
*         3. DOWNLOAD ALL PARAMETER ENTRIES MADE BY THE USER
*            PRIOR TO THE TEST LOAD INTO THE NDI/CLM COMMON 
*            MEMORY LOCATIONS.
* 
*         4. NOW THE MONITOR MUST WAIT FOR THE CCC TO RESPOND THAT
*            THE PARAMETERS SENT WERE RECEIVED INTO CCC MEMORY. 
*            IF THE CCC ACKNOWLEDGES THAT THE PARAMETERS WERE 
*            RECEIVED, THE MONITOR CONTINUES AT 5.  IF THE MONITOR
*            RECEIVES NO ACKNOWLEDGE WITHIN A REASONABLE AMOUNT OF
*            TIME, THE MONITOR WILL STOP AND DISPLAY THE FOLLOWING
*            ERROR MESSAGE -"NO NDI RESPONSE".  THE USER MAY
*            RECOVER FROM THIS ERROR BY ENTERING A GO.  A GO COMMAND
*            WILL ACTUALLY RE-RUN THE BASIC MONITOR LOOP BEGINNING
*            AT 2.
* 
*         5. DISPLAY THE CURRENT TEST STATUS
* 
*            A. IF THE STATUS WORD DOESNT CONTAIN ANY STATUS, THE 
*               FOLLOWING ERROR MESSAGE WILL APPEAR "NO STATE BITS
*               SET".  THE USER CAN RECOVER BY ENTERING GO TO 
*               RERUN THE BASIC MONITOR LOOP. 
* 
*            B. IF THE TEST HAS STOPPED ON A USER SELECTED STOP 
*               THAT IS, A STOP AT BEGINNING OF TEST OR STOP AT 
*               END OF CONDITION, THE MONITOR WILL STOP AND REPORT
*               THIS INFORMATION TO THE USER.  THE USER 
*               CAN THEN CONTINUE WITH A GO.
* 
*            C. THE CCC RESIDENT TEST HAS BEEN WRITTEN TO PAUSE 
*               AT FREQUENT INTERVALS IN ORDER TO GIVE THE MONITOR
*               TIME TO DISPLAY THE TEST STATUS WHILE THE TEST
*               IS RUNNING.  IF THE TEST HAS STOPPED FOR THIS 
*               REASON, THE MONITOR WILL AUTOMATICALLY GIVE THE 
*               TEST A CONTINUE.  AND THE USER WILL NOT BE
*               AWARE OF THESE STOPS. 
* 
*            D. IF THE TEST STOPPED ON AN ERROR AND SCOPE LOOPING 
*               HAS BEEN ENABLED, THE MONITOR WILL NOT STOP AND 
*               REPORT THE ERROR BUT CONTINUE AT 7. 
* 
*               IF THE TEST STOPPED ON AN ERROR BUT SCOPE LOOPING 
*               HAS NOT BEEN ENABLED, THE MONITOR WILL STOP AND 
*               REPORT THE ERROR.  WHEN THE USER ENTERS GO, 
*               THE TEST WILL CONTINUE AT 7.
* 
* 
*         6. IF THE TEST STATE INDICATES THAT THE TEST IS RUNNING 
* 
*            IF THE PROCESSOR HAS STOPPED WHILE THE TEST IS EXECUTING 
*            THE MONITOR MAY NOT BE AWARE OF IT.  THE ONLY WAY THE
*            MONITOR HAS TO DETERMINE IF THE PROCESSOR IS ACTUALLY
*            RUNNING IS TO CHECK THE CCC PROCESSOR HARDWARE STATUS. 
*            THEREFORE, THE MONITOR GIVES EACH TEST CONDITION AMPLE 
*            TIME TO EXECUTE.  IF THE TEST HAS NOT STOPPED AFTER THIS 
*            LENGTH, THE MONITOR BECOMES SUSPICIOUS AND WILL CHECK
*            THE HARDWARE STATUS TO SEE IF THE PROCESSOR IS RUNNING.
*            SINCE THE TEST SHOULD HAVE STOPPED DURING THIS TIME, IT
*            IS EVIDENT THAT THE CCC PROCESSOR IS STOPPED.  THE 
*            MONITOR WILL NOW REPORT THAT THE CCC PROCESSOR IS
*            STOPPED ALONG WITH THE HARDWARE STATUS AND CCC ADDRESSES 
*            4-F .  THE USER CAN CONTINUE BY ENTERING 
*            A GO.
* 
*            IF THE TIME-OUT HAS NOT BEEN REACHED, THE MONITOR WILL 
*            ASSUME THAT THE PROCESSOR AND TEST ARE STILL RUNNING 
*            AND CONTINUE AT 2. 
* 
*         7. THE TEST STOP HAS ALREADY BEEN PROCESSED AND THE 
*            USER HAS ENTERED A GO TO CONTINUE TESTING.  THE
*            MONITOR WILL NOW SEND A CONTINUE FUNCTION TO THE 
*            TEST WHICH WILL CAUSE THE TEST TO CONTINUE EXECUTION.
*            THE MONITOR WILL NOW CONTINUE AT 2.
* 
   MODULE CLM00,6000,(31,32,46,47,53,104,105,115)LOCK 
***       CLM00 - PARAMETER CHECKER 
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         THE CONTENTS OF THE PARAMETER REGISTERS P3,P4 
*         WILL BE CHECKED FOR ILLEGAL DATA. 
* 
*    1.2  METHOD
* 
*         1.  CHECK P1 REGISTER FOR LEGAL ENABLE BITS SET.
*             REPORT AN ERROR IF ILLEGAL BITS SET.
*         2.  CHECK P4 REGISTER FOR LEGAL DISABLE BITS
*             SET.  REPORT AN ERROR IF ILLEGAL BITS SET.
*         3.  CHECK IF REPEAT MODULE IS SET 
*         4.  CHECK P5 AND P6 FOR LEGAL ENABLES.  REPORT
*             ERROR IF ILLEGAL BITS SET.
*         5.  PAUSE FOR USER TO CORRECT THE PARAMETER 
*             WORD AND RE-RUN CLM.
* 
*    1.3  ERRORS REPORTED 
* 
*         CLM00 - PARAMETER ERROR DETECTED
*         CLM00 - ILLEGAL MEMORY SIZE SET  (P1) 
*         CLM00 - ILLEGAL DISABLES SET (P4) 
*         CLM00 - RM ILLEGALLY SET
*         CLM00 - ILLEGAL MODULE SELECT IN P5 
*         CLM00 - ILLEGAL MODULE SELECT IN P6 
*         PLEASE CORRECT PATAMETER AND RE-RUN CLM 
* 
* 
/    2.0  INTERNAL MODULE DOCUMENTATION 
* 
*    2.1       ENTRY CONDITIONS 
* 
*         CLM00 IS THE FIRST MODULE RUN FOLLOWING 
*         A **RUN CLM** COMMAND.
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         P1, P4, P5, P6,  STANDARD USAGE.
*         BUFFERS USED - NONE.
* 
*    2.3  SUBMODULES USED - NONE
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT CCC LOADER AND MONITOR(CLM) 
2  FORMAT CLM00 - PARAMETER CHECKER 
3  FORMAT CLM00 - PARAMETER ERROR DETECTED
4  FORMAT CLM00 - ILLEGAL MEMORY SIZE SET  (P1) 
5  FORMAT CLM00 - ILLEGAL DISABLES SET (P4) 
6  FORMAT PLEASE CORRECT PARAMETER AND RE-RUN CLM 
7  FORMAT CLM00 - RM ILLEGALLY SET
10 FORMAT CLM00 - ILLEGAL MODULE SELECT IN P5 
11 FORMAT CLM00 - ILLEGAL MODULE SELECT IN P6 
* 
* -----------------INITIALIZATION---------------------------
* 
30 MSG 1 TO PRINT,DISPLAY 
   MSG 2 TO PRINT,DISPLAY 
* 
* -----------------TEST-------------------------------------
* 
32 IF(P1.AND.7770.EQ.0) GOTO 40  *IF LEGAL ENABLES SET
   MSG 1 TO LINE 1
   MSG 2 TO LINE 2
   MSG 3 TO LINE 3
   MSG 4 TO LINE 4
   MSG 4 TO PRINT,DISPLAY 
   MSG 6 TO LINE 6
34 PAUSE
   GOTO 34
* 
40 IF(P4.AND.7776.EQ.0) GOTO 50  *IF LEGAL DISABLES SEL.
   MSG 1 TO LINE 1
   MSG 2 TO LINE 2
   MSG 3 TO LINE 3
   MSG 5 TO LINE 4
   MSG 5 TO PRINT,DISPLAY 
   MSG 6 TO LINE 6
42 PAUSE
   GOTO 42
* 
* -----------------REPEAT/EXIT------------------------------
* 
50 IF(ES.AND.RM.EQ.0) GOTO 60     *IF RM NOT SET
   MSG 1 TO LINE 1
   MSG 2 TO LINE 2
   MSG 3 TO LINE 3
   MSG 7 TO LINE 4
   MSG 7 TO PRINT,DISPLAY 
   MSG 6 TO LINE 6
52 PAUSE
   GOTO 52
* 
60 IF(P5.LT.144B) GOTO 64         *IF LEGAL MODULE SEL PARAM
   MSG 1 TO LINE 1
   MSG 2 TO LINE 2
   MSG 3 TO LINE 3
   MSG 10 TO LINE 4 
   MSG 10 TO PRINT,DISPLAY
   MSG 6 TO LINE 6
62 PAUSE
   GOTO 62
* 
64 IF(P5+P6.LT.144B) GOTO 76      *IF LEGAL MODULE SELECTS
   MSG 1 TO LINE 1
   MSG 2 TO LINE 2
   MSG 3 TO LINE 3
   MSG 11 TO LINE 4 
   MSG 11 TO PRINT,DISPLAY
   MSG 6 TO LINE 6
66 PAUSE
   GOTO 66
* 
76 EXIT 
* 
   END 30 
COMPILE                      CLM00 -   CHECKS PARAMETERS
   MODULE CLM01,6000,(31,32,46,47,53,104,105,115)LOCK 
***       CLM01 - CCC TEST LOADER 
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         CLM01 LOADS NDI(TEST INTERFACE) AND THE CCC TEST
*         INTO CCC MEMORY FROM THE SCRATCH FILE.  EVEN THOUGH 
*         77 AND 6PPM TABLE ARE PART OF THE SCRATCH FILE THEY 
*         ARE USED FOR FILE INFORMATION ONLY.  THESE TABLES 
*         ARE NOT TRANSFERRED TO THE CCC MEMORY.
* 
*    1.2  METHOD
* 
*         1. THE IN-LINE DIAGNOSTICS ARE INVOKED  VIA A ZERO LENGTH 
*            AUTOLOAD. IF THEY EXECUTE CORRECTLY THE TEST LOAD CON- 
*            TINUES.  WHEN THE DIAGNOSTICS FAIL, THE OPERATOR IS
*            NOTIFIED AND GIVEN THE OPTION TO CONTINUE LOADING OR 
*            TERMINATE THE LOAD.
* 
*         2. THE CCC PROCESSOR IS MASTER CLEARED. THIS WILL ALSO
*            STOP THE CCC PROCESSOR - A PREREQUISITE BEFORE LOADING 
*            THE SOFTWARE INTO THE CCC. 
* 
*         3. THE FIRST 500B WORDS OF THE SCRATCH FILE ARE ENTERED 
*            INTO PP MEMORY(IB).  CONTAINED IN THIS 500B WORD BLOCK 
*            ARE THE 77 AND 6PPM TABLES IN ADDITION TO SOME TEST
*            SOFTWARE.
*                          77 AND 6PPM TABLE
* 
*                    -------------------------------- 
*                WD  ---1------2------3-----4-----5-- 
*                   6-     -      -      -     -    - 
*                  13-     -      -      -     -    - 
*                  20-     -      -      -     -    - 
*                  25-     -      -      -     -    - 
*                  32-     -      -      -     -    - 
*                  37-     -      -      -     -    - 
*                  44-     -      -      -     -    - 
*                  51-     -      -      -     -    - 
*                  56-     -      -      -     -    - 
*                  63-     -      -      -     -    - 
*                  70-     -      -      -     -    - 
*                  75-     -      -      -     -    - 
*                 102-     -      -      -     -    - 
*                 107-     -      -      -     -113B- 
*                    -------------------------------- 
* 
*                     PP WORD 2 = NUMBER OF CM WORDS IN 77+6PPS TABLES
*                     PP WORD 113B = NUMBER OF CM WORDS IN TEST 
*                                    (THIS INCLUDES THE 6PPM TABLE WORD 
*                                     (WD.107-113B) 
* 
*         4. THE NUMBER OF ACTUAL PP TEST WORDS PRESENTLY IN THE INPUT
*            BUFFER MUST BE CALCULATED TO SET THE WC REGISTER FOR THE 
*            FIRST WRITE TO THE CCC.
* 
*         5. EACH ADDITIONAL BLOCK (500 PP WORDS) OF THE TEST SOFTWARE
*            TO BE SENT TO THE CCC WILL INCREMENT THE BLOCK COUNTER 
*            IB(BLOCK) BY 1.  IF A BLOCK OF FEWER THAN 500 WORDS
*            REMAINS, THIS PP WORD COUNT WILL BE STORED IN IB(PPWDS). 
* 
*         7. THE CCC WORD COUNT OF THE TEST (2PP WORDS=1 CCC WORD)  IS
*            CALCULATED.
* 
*         8. USING THE CCC WORD COUNT, THE ADDRESS AND LENGTH REGISTERS 
*            IN THE DEVICE INTERFACE ARE SET. 
* 
*         9. THE TEST WILL NOW BE WRITTEN INTO CCC MEMORY.  EACH TIME A 
*            BLOCK OF DATA IS SENT, THE BLOCK COUNT WILL BE DECREMENTED 
*            UNTIL ALL BLOCKS INCLUDING THE BLOCK COUNT IN IB(PPWDS) IS 
*            TRANSFERRED.  THE I/O CHANNEL WILL REMAIN ACTIVE (USING
*            THE OUTB CHAIN COMMAND) UNTIL A DEACTIVATE COMMAND IS
*            GIVEN TO THE CHANNEL.  THIS IS THE ONLY WAY THAT A LONG
*            TEST CAN BE WRITTEN INTO THE CCC MEMORY WITHOUT RESETTING
*            THE ADDRESS AND LENGTH REGISTERS FOR EVERY BLOCK TRANSFER. 
* 
*    1.3  ERRORS REPORTED 
* 
*         E0002 - CHANNEL PARITY ERROR
*         E0003 - TEST LOADED INCORRECTLY 
*         E0004 - TEST NOT IN SYSTEM FILE 
*         PROCESSOR ERROR ON MASTER CLEAR 
* 
/    2.0  INTERNAL MODULE DOCUMENTATION 
* 
*    2.1  ENTRY CONDITIONS
* 
*         THE TEST INCLUDING THE TEST INTERFACE MUST BE CONTAINED ON
*         THE SYSTEM FILE.
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         B11 - INDICATES AN ERROR IN CCC WORDS 4-F.
*         WC  = NUMBER OF WORDS IN PP BUFFER TO TRANSFER TO CCC 
*         BA  = FIRST WORD OF PP OUTPUT BUFFER TO BE SENT TO CCC MEMORY 
* 
*         BUFFERS USED -
*         TO SET THE ADDRESS AND LENGTH REGISTERS IN THE CCC THE
*            FOLLOWING LOCATIONS ARE USED IN THE PP_
*         OB(501) = CCC ADDRESS REGISTER
*         OB(502) = CCC LENGTH REGISTER 
* 
*         IB(BLOCK) = IB(502) - HOLDS NUMBER OF 500 WORD BLOCKS TO
*                     TRANSFER
*         IB(PPWDS) = IB(501) - HOLDS NUMBER OF PP WORDS TO TRANSFER
*         IB(0) = WORKING BUFFER LOCATION 
*         IB(1) = WORKING BUFFER LOCATION 
* 
*    2.3  SUBMODULES USED 
* 
*         CLM01A - CALCULATES THE CCC TEST LENGTH 
*         CLM01B - REPORTS A PROCESSOR MASTER CLEAR ERROR 
*         CLM01C - INVOLKE THE IN-LINE DIAGNOSTICS
* 
*         REMARKS -  THE PROCESSOR MUST BE STOPPED BEFORE LOADING THE 
*         TEST.  BY ISSUING A MASTER CLEAR FUNCTION IN THIS MODULE, THE 
*         PROCESSOR IS STOPPED. THE LOAD MAY NOT FUNCTION PROPERLY IF 
*         THE PROCESSOR DOES NOT STOP.
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT CCC LOADER AND MONITOR(CLM) 
2  FORMAT CLM01 - CCC LOADER
3  FORMAT *A*A*A LOADING
4  FORMAT *A*A*A LOADED 
5  FORMAT *A*A*A LOAD CONFIRMED 
6  FORMAT E0004 - TEST NOT IN SYSTEM FILE 
7  FORMAT E0002 - CHANNEL PARITY ERROR
10 FORMAT E0003 - TEST LOADED INCORRECTLY 
11 FORMAT         ENTER GO TO RELOAD THE TEST 
   EQUATE CSTATUS=0704,PMC=0740 
   EQUATE SETADDR=500,LWRT=0702 
   EQUATE RD8=0701
* 
* -----------------INITIALIZATION---------------------------
* 
*                                 *MASTER CLR CCC PROCESSOR 
20 MSG 2 TO PRINT,DISPLAY 
22 CALL 01C                       *INVOKE IN-LINES/CHECK
   RES, ABT 74
   FUNC PMC, ABT 74               *MC CCC PROCESSOR 
   DELAY 50 USEC
   CALL 01B                       *CHECK CCC WORDS 4-F
* 
* -----------------TEST-------------------------------------
* 
*                                 *CALCULATE TEST LENGTH
24 SYSREW 
   RES, ABT 74
   SYSREW 
   SYSRD, STATUS TO B10 
   IF(IB(0).NE.7700) ERROR 06/04, GOTO 74 
   CALL 01A                       *CALCULATE TEST LENGTH
*                                 *WRT TEST INTO CCC MEMORY 
   SYSREW                         *REWIND SCRATCH FILE
   OB(501)=0                      *CCC ADDRESS
   OB(502)=0                      *CCC LENGTH 
   GOSUB 50                       *SET ADDR AND LENGTH REG. 
* 
   MSG 3(B5,B6,B7,B10) TO PRINT,DISPLAY 
   RES, ABT 74
30 FUNC LWRT, ABT 74
   SYSRD, STATUS TO B10           *READ BLOCK OF DATA TO PP 
   RES, ABT 74
   COPY IB(BA) TO OB(0) FOR WC    *XFER DATA FROM IB TO OB
   OUTB CHAIN WC WORDS FROM OB(0), ABT 74  *WRITE DATA
   BA=0                           *RESET BEGINNING ADDRESS
32 SYSRD, STATUS TO B10           *READ BLOCK OF DATA TO PP 
   WC=WT
   IF(WC.EQ.0) GOTO 34
   COPY IB(BA) TO OB(0) FOR WC    *XFER DATA FROM IB TO OB
   OUTB CHAIN WC WORDS FROM OB(0), ABT 74  *WRITE DATA
   IF(B10.EQ.0) GOTO 32 
34 DCN, ABT 74                    *DEACT. CHAN. AFTER CHAIN 
   MSG 4(B5,B6,B7,B10) TO PRINT,DISPLAY 
*                                 *VERIFY THE TEST LOADED 
*                                 *CORRECTLY (5C=F501)
35 OB(501)=134B                   *CCC ADDRESS
   OB(502)=1                      *CCC LENGTHS
   GOSUB 50                       *SET ADDR AND LENGTH REG. 
* 
   FUNC RD8, ABT 74 
   INB 2 WORDS TO IB(0), ABT 74   *READ WORD 5C 
   IF(IB(0).NE.365B), ERROR 10/03, GOTO 74  *EC=03********
   IF(IB(1).NE.001B), ERROR 10/03, GOTO 74  *EC=03********
   MSG 5(B5,B6,B7,B10) TO PRINT,DISPLAY 
   RES, ABT 74
   FUNC PMC, ABT 74 
   EXIT 
*                                 *SET ADDR AND LENGTH REGS 
50 RES, ABT 74
   FUNC SETADDR, ABT 74 
   OUTB 2 WORDS FROM OB(501), ABT 74  *OUTPUT ADDR./LENGTH
   FUNC CSTATUS, ABT 74 
   INB 1 WORDS TO IB(0),ABT 74
   IF(IB(0).AND.2000.EQ.0) RETURN  *IF CHANNEL PARITY ERROR 
   ERROR 07/02, GOTO 74           *EC=02**********
* 
* -----------------MODULE ERRORS PROCESSOR------------------
* 
74 MSG 1 TO LINE 1
   MSG 2 TO LINE 2
   MSG EM TO LINE 4                *DISPLAY ERROR MESSAGE 
   PICTURE
   HALT 
76 BLANK
   ENDSUB, GOTO 22
   END 20 
COMPILE                      CLM01 - LOADS CCC
   MODULE CLM01A,6000,(31,32,46,47,53,104,105,115)LOCK
***       CLM01A - CALCULATE TEST LENGTH
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         CLM01A WILL CALCULATE THE LENGTH OF THE TEST
*         IN A CCC WORD COUNT.
* 
*    1.2  METHOD
*         1. CALCULATE THE NUMBER OF TEST WORDS IN THE FIRST
*            BLOCK TRANSFER.  (REMEMBER TABLES 77 AND 6PPS
*            MAKE UP PART OF THIS BLOCK.
*         2. SET THE BA AND WC REGISTERS FOR THE FIRST
*            BLOCK TRANSFER TO THE CCC. 
*         3. CALCULATE THE TOTAL NUMBER OF PP WORDS IN THE
*            TEST.
*         4. CALCULATE THE TOTAL NUMBER OF CCC WORDS IN THE 
*            TEST.
*         5. SET IB(LENGTH1) AND IB(LENGTH2) TO HOLD THE
*            TOTAL NUMBER OF CCC WORDS TO BE WRITTEN. 
* 
*    1.3  ERRORS REPORTED - NONE. 
* 
/    2.0  INTERNAL MODULE DOCUMENTATION 
* 
*    2.1  ENTRY CONDITIONS
* 
*         THE TEST HAS A HEADER WHEN IT EXISTS ON 
*         THE SCRATCH FILE.  THIS HEADER IS NOT TRANSFERRED 
*         TO THE CCC MEMORY.
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         B1=NUMBER OF CM WORDS IN HEADER 
*         B2=NUMBER OF PP WORDS IN HEADER 
*         B10=STATUS OF SYSTEM READ FUNCTION
*         B4=SCRATCH REGISTER 
* 
*         BA,EM,EC,WC,WT - STANDARD USAGE 
* 
*         BUFFERS USED -
*         IB(TOTALL)/IB(501)  =LOWER BITS OF PP WORD LENGTH 
*         IB(TOTALU)/IB(502) =UPPER BITS OF PP WORD LENGTH
*         IB(LENGTHL)=IB(503)=LOWER BITS OF CCC WORD LENGTH 
*         IB(LENGTHU)=IB(504)=UPPER BITS OF CCC WORD LENGTH 
*         OB(FBUFWC)=OB(500) =TEST WC OF FIRST BUFFER 
*         IB(LBUFWC)=IB(500) =TEST WC OF LAST BUFFER
* 
*    2.3  SUBMODULES USED - NONE. 
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT CALCULATING LENGTH OF *A*A
* 
   EQUATE TOTALL=501, TOTALU=502
   EQUATE LENGTHL=503, LENGTHU=504
* 
* -----------------INITIALIZATION---------------------------
* 
*                                 *NUM. TEST WDS - 1ST BUFF.
20 B1=IB(1)+2                     *B1=CM WORDS IN HEADER
   B5=IB(5)                       *FIRST CHARACTER
   B6=IB(6)                       *SECOND CHARACTER 
   B7=IB(7)                       *THIRD CHARACTER
   B10=IB(10)                     *FOURTH CHARACTER 
   MSG 1(B5,B6,B7,B10) TO PRINT,DISPLAY 
* 
* -----------------TEST-------------------------------------
* 
   GOSUB 40                       *CALCULATE
* 
   BA=B2                          *ADDR. OF FIRST CW WORD 
   WC=500B-B2                     *WC OF FIRST BUFFER 
*                                 *NUM. TEST WRDS (PP COUNT)
22 B0=B2-2                        *UPPER 12 BITS OF CM COUNT
   B1=B2-1                        *LOWER 12 BITS OF CM COUNT
   B0=IB(B0)
   B1=IB(B1)
   GOSUB 40 
* 
   IB(TOTALL)=B2                  *LOWER 12 BITS OF PP COUNT
   IB(TOTALU)=B3                  *UPPER 12 BITS OF PP COUNT
*                                 *NUMBER OF CCC WDS IN TEST
32 B4=IB(TOTALU).AND.1.LS.11D 
   IB(LENGTHL)=IB(TOTALL)RS.1.+B4  *LOWER PP WC 
   IB(LENGTHU)=IB(TOTALU).RS.1    *UPPER PP WC
*                                 *SET UP FOR 12/16 ASSEM./ 
*                                 *DISASSEMBLY MODE.
   B4=IB(LENGTHL).AND.7400.RS.8D
   IB(LENGTHL) = IB(LENGTHL).AND.0377   *LOWER CCC WC 
   IB(LENGTHU) = IB(LENGTHU).LS.4.+.B4  *UPPER CCC WC 
   EXIT 
* 
* -----------------SUBROUTINES------------------------------
* 
*                                 *CONV. CM WC TO PP WC 
40 B2=0                           *CLEAR WORKING REGISTER 
   B3=0                           *CLEAR WORKING REGISTER 
42 IF(B2+5.GT.7777) B3=B3+1       *INCR UPPER WORD OF PP WC 
   B2=B2+5                        *INCR LOWER WORD OF PP WC 
   B1=B1-1                        *DECR LOWER WORD OF CM WC 
   IF(B1.NE.0) GOTO 42
   IF(B0.NE.0) GOTO 44
   IF(B2.AND.1.EQ.0) RETURN       *CONV. COMP.-EVEN PP CT 
   IF(B2+1.GT.7777)B3=B3+1        *MAKE PP COUNT EVEN 
   B2=B2+1
   RETURN 
* 
44 B0=B0-1                        *DECR UPPER WORD OF CM WC 
   B1=7777                        *INCR LOWER WORD OF CM WC 
   GOTO 42
* 
   END 20 
COMPILE                      CLM01A - CALC LENGTH OF TEST 
   MODULE CLM01B,6000,(31,32,46,47,53,104,105,115)LOCK
***       CLM01B - CHECK 4-F AFTER PMC/REPORT ERRORS
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         CLM01B WILL REPORT THE FOLLOWING ERRORS_
*         1. MISCOMPARE ON LOC E BIT 9 AFTER MASTER CLR FUNCTION (PMC)
* 
*    1.2  METHOD
* 
*         1. READ CONTENTS OF E 
*         2. DISPLAY CONTENTS OF 4-F
*         3. REPORT HARDWARE STATUS IF NON-ZERO.
* 
*    1.3  ERRORS REPORTED 
* 
*         E0002 - CHANNEL PARITY ERROR
*           CCC HARDWARE STATUS = *OCTB 
*              CONTENTS OF LOCATIONS 4-F
*           4=*H*H H   5=*H*H H    6=*H*H H    7=*H*H H 
*           8=*H*H H   9=*H*H H    A=*H*H H    B=*H*H H 
*           C=*H*H H   D=*H*H H    E=*H*H H    F=*H*H H 
*               PROCESSOR ERROR ON MASTER CLEAR 
* 
/    2.0  INTERNAL DOCUMENTATION
* 
*    2.1  ENTRY CONDITIONS
* 
*         CLM01B IS ENTERED FROM CLM01 FOLLOWING PROCESSOR
*         MASTER CLEAR. 
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         EM,EC,WC - STANDARD USAGE 
* 
*         BUFFERS USED -
*         OB(501) = CCC ADDRESS REGISTER
*         OB(502) = CCC LENGTH REGISTER 
*         IB(0) = HARDWARE/CONTROLWARE STATUS 
*         IB(1-71) = CONTENTS OF 4-F
* 
*    2.3  SUBMODULES REFERENCED - NONE. 
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT CCC LOADER AND MONITOR(CLM) 
2  FORMAT CLM01 - CCC TEST LOADER 
3  FORMAT E0002 - CHANNEL PARITY ERROR
4  FORMAT   CCC HARDWARE STATUS = *OCTB 
5  FORMAT      CONTENTS OF LOCATIONS 4-F
6  FORMAT   4=*H*H H   5=*H*H H    6=*H*H H    7=*H*H H 
7  FORMAT   8=*H*H H   9=*H*H H    A=*H*H H    B=*H*H H 
10 FORMAT   C=*H*H H   D=*H*H H    E=*H*H H    F=*H*H H 
20 FORMAT       PROCESSOR ERROR ON MASTER CLEAR 
21 FORMAT         PLEASE ENTER GO TO CONTINUE 
22 FORMAT --------------------------------------------- 
* 
   EQUATE CSTATUS=0704, SETADDR=0500
   EQUATE RD8=0701
24 RES, ABT 74
* 
* -----------------TEST-------------------------------------
* 
*                                 *CHK AND RPT 4-F MISCOMP. 
30 OB(501)=4                      *CCC ADDRESS
   OB(502)=14B                    *CCC LENGTH 
   GOSUB 50 
* 
   FUNC RD8, ABT 74               *READ WORDS 4-F.
   INB 30B WORDS TO IB(1), ABT 74 
   IF(IB(26).AND.100.NE.100.) GOTO 32 
   EXIT 
* 
32 MSG 5 TO LINE 7
   MSG 6 10 WORDS FROM IB(1) TO LINE 8D   *DISPLAY WORDS 4-F
   MSG 7 10 WORDS FROM IB(11) TO LINE 9D
   MSG 10 10 WORDS FROM IB(21) TO LINE 10D
*                                 *REPORT HARDWARE STATUS 
45 FUNC CSTATUS, ABT 74 
   INB 1 WORDS TO IB(0), ABT 74 
   IF(IB(0).AND.3601.NE.0) MSG 4(IB(0)) TO LINE 6 
   MSG 20 TO LINE 4 
   MSG 21 TO LINE 5 
   GOTO 74
* 
* -----------------SUBROUTINES------------------------------
* 
*                                 *SET ADDR AND LENGTH REGS 
50 FUNC SETADDR, ABT 74 
   OUTB 2 WORDS FROM OB(501), ABT 74  *OUTPUT ADDR./LENGTH
   FUNC CSTATUS, ABT 74 
   INB 1 WORDS TO IB(0),ABT 74    *INPUT CONTROLLER STATUS
   IF(IB(0).AND.2000.EQ.0) RETURN  *IF CHANNEL PARITY ERROR 
   ERROR 03/02, GOTO 74           *EC=02**********
* 
* -----------------ERROR PROCESSOR--------------------------
* 
74 MSG 1 TO LINE 1
   MSG 2 TO LINE 2
   MSG EM TO LINE 3 
   PICTURE
   HALT 
   MSG 22 TO PRINT
   BLANK
   ENDSUB 
   EXIT 
* 
   END 24 
COMPILE                      CLM01B - REPORTS MCLR ERRORS 
   MODULE CLM01C,6000,(31,32,46,47,53,104,105,115)LOCK
***       CLM01C - INVOKE IN-LINE DIAGS 
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         CLM01C WILL REPORT THE FOLLOWING ERRORS.
*         1. NO RESPONSE FROM CCC WITHIN 500 MS OF
*            FUNCTIONING A ZERO LENGTH AUTOLOAD.
*         2. IN-LINE DIAGNOSTIC FAILURE AND THE 
*            ERROR CODE(GENERAL STATUS).
* 
*    1.2  METHOD
* 
*         1. FUNCTION A ZERO LENGTH AUTOLOAD. 
*         2. ABORT FUNCTION AND REPORT A CCC HANGUP IF
*            NO RESPONSE WITHIN 500 MS. 
*         3. IF CCC REPLIES TO THE FUNCTION, CHECK THE
*            GENERAL STATUS AND REPORT THE ERROR CODE 
*            IF NOT EQUAL TO ZERO.
* 
*    1.3  ERRORS REPORTED 
* 
*         E0005 - IN-LINE DIAG ERROR
*           CCC ERROR CODE = *OCTB
* 
*         CCC IN-LINE FAILURE - NO
*          RESPONSE WITHIN 500 MS 
* 
/    2.0  INTERNAL DOCUMENTATION
* 
*    2.1  ENTRY CONDITIONS
* 
*         CLM01C IS ENTERED FROM CLM01 PRIOR TO ATTEMPTING
*         TO LOAD A TEST INTO THE CCC.
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         EM,EC - STANDARD USAGE
* 
*         BUFFERS USED -
*         SB(1) = CCC GENERAL STATUS
* 
*    2.3  SUBMODULES REFERENCED - NONE. 
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT CCC LOADER AND MONITOR(CLM) 
2  FORMAT CLM01 - CCC TEST LOADER 
3  FORMAT E0005 - IN-LINE DIAG ERROR
4  FORMAT   CCC ERROR CODE = *OCTB
5  FORMAT   CCC IN-LINE FAILURE - NO
6  FORMAT    RESPONSE WITHIN 500 MS 
7  FORMAT CLM01 - PAUSE IN-LINES FAILED 
10 FORMAT ENTER GO TO RETRY THE IN-LINES. CAUTION:  
11 FORMAT ALL ERROR INFO IN CCC MEMORY WILL BE LOST.
12 FORMAT --------------------------------------------- 
* 
* -----------------TEST-------------------------------------
* 
20 RES, ABT 74
   TIMEOUT TYPEB=500000 USEC      *ALLOW IN-LINES 500MS 
   FUNC 0414, ABT 60              *FUNCTION AUTOLOAD
   TIMEOUT TYPEB=262000 USEC      *RETURN TIMEOUT TO NORMAL 
   FUNC 12, ABT 74                *GET GENERAL STATUS 
   INB 1 WORDS TO IB(1), ABT 74 
   IF(IB(1).EQ.0) EXIT            *EXIT,IN-LINES RAN OK 
   B1 = 0 
   IF(DC.EQ.53) B1 = 1000         *EXPECTED STATUS FOR 698 TAPE 
   IF(DC.EQ.47) B1 = 1000         *EXPECTED STATUS FOR CART TAPE
   IF(DC.EQ.46) B1 = 1000         *EXPECTED STATUS FOR CART TAPE
   IF(IB(1).EQ.B1) EXIT           *EXIT,IN-LINES RAN OK 
   IF(IB(1).EQ.5403) EXIT         *EXIT,IN-LINES RAN OK 
   MSG 4(IB(1)) TO LINE 4 
   ERROR 03/05, GOTO 62 
   EXIT                           *EXIT, IN-LINES RAN OK
* 
* -----------------SUBROUTINES------------------------------
* 
60 IF(EC-4024.NE.0) GOTO 74       *IF ERR NOT DUE TO NO INAC
   MSG 5 TO LINE 5                *DISPLAY MESSAGES IF THE
   MSG 6 TO LINE 6                *ABORT WAS DUE TO THE CHAN
62 MSG 10 TO LINE 7               *BEING INACT AFTER FUNC.
   MSG 11 TO LINE 10
* 
  
* -----------------ERROR PROCESSOR--------------------------
* 
74 MSG 1 TO LINE 1
   MSG 2 TO LINE 2
   MSG EM TO LINE 3 
   PICTURE
   HALT 
   MSG 12 TO PRINT
   BLANK
   ENDSUB GOTO 20 
76 EXIT 
* 
   END 20 
COMPILE                      CLM01C - INVOLKE IN-LINES
   MODULE CLM02,6000,(31,32,46,47,53,104,105,115)LOCK 
***       CLM02 - CCC TEST MONITOR
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         CLM02 IS A MONITOR ROUTINE WHICH BECOMES THE COMMUNICATION
*         LINK BETWEEN THE CCC TEST AND USER.  THE MONITOR WILL 
*         CONTINUOUSLY UPDATE THE DISPLAY, PROVIDING THE USER 
*         WITH CURRENT INFORMATION ON THE TEST-S PROGRESS AND ERROR 
*         INFORMATION WHEN AN ERROR OCCURS.  THE USER CAN, IN 
*         TURN, RESPOND TO THIS INFORMATION BY ALTERING THE COURSE OF 
*         A TEST THROUGH CHANGES TO THE PARAMETER REGISTERS AND 
*         EXECUTIVE SWITCHES.  IF THE CONTENTS OF A PARAMETER REGISTER
*         IS CHANGED, CLM MUST BE RE-RUN. 
* 
*    1.2  METHOD
* 
*         1. AFTER THE TEST/TEST INTERFACE HAS BEEN LOADED INTO CCC 
*            MEMORY A PROCESSOR GO FUNCTION WILL BE SENT FROM THE PP TO 
*            BEGIN TEST EXECUTION.
*         2. FROM NOW ON, THE MONITOR WILL WATCH THE STATE OF THE TEST
*            - THE STATE OF THE TEST IS CONTAINED IN A LOCATION IN
*              CCC MEMORY.  IT IS CONTINUOUSLY BEING UPDATED BY NDI.
* 
*                A. IF THE TEST IS RUNNING, THE MONITOR WILL LOOP ON
*                   THE FOLLOWING FUNCTIONS.
* 
*                     1. UPDATE THE DISPLAY SO THAT THE USER WILL 
*                        BE INFORMED OF THE TEST-S PROGRESS.
* 
*                     2. SEND ANY CHANGES THE USER HAS MADE IN THE
*                        PARAMETER AND/OR EXECUTIVE SWITCHES REGISTER 
*                        TO THE CCC AND MAKE SURE THAT THE TEST 
*                        INTERFACE ACKNOWLEDGES THESE CHANGES.
* 
*                B. IF THE TEST IS STOPPED, THE MONITOR WILL EXECUTE
*                   THE FOLLOWING FUNCTIONS.
* 
*                     1. DISPLAY THE REASON WHY THE TEST IS STOPPED.
* 
*                     2. IF THE TEST IS STOPPED ON AN ERROR, DISPLAY
*                        ERROR INFORMATION. 
* 
*                     3. WAIT FOR THE USER TO ISSUE A GO SO THAT
*                        THE TEST CAN PROCEED.
* 
*    1.3  ERRORS REPORTED 
* 
*         *A*A*D   EC=*DECD LC=*DECD
*         LAST CALL TO NDI FROM ADDRESS *H*H H
*         ADDR=*H*H H 
*                    ECNT=*DECD      ICNT=*DECD 
*         E0003 - CHANNEL PARITY ERROR
* 
/    2.0  INTERNAL MODULE DOCUMENTATION 
* 
*    2.1  ENTRY CONDITIONS
* 
*         THE TEST IS LOADED. 
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         B0  = NDI STATE STATUS. 
*         B1  = LOOP COUNTER FOR ACKNOWLEDGE. 
*         B2  = LOOP COUNTER FOR RUNNING. 
*         B3  = NDI FUNCTION CODE.
*         B4  = EXCESSIVE EXECUTION TIME INDICATOR. 
*         B6  = PROCESSOR GO FUNCTION INDICATOR.
*         B7  = ERROR COUNT.
*         B8  = DISPLAY INITIALIZATION FLAG.
*         B9  = OVERFLOW INDICATOR. 
*         B14 = WORKING REGISTER. 
*         B15 = WORKING REGISTER. 
* 
*         BUFFERS USED -
*         TO SET THE ADDRESS AND LENGTH REGISTERS IN THE CCC THE
*            FOLLOWING LOCATIONS ARE USED IN THE PP_
*         OB(501) = CCC ADDRESS REGISTER
*         OB(502) = CCC LENGTH REGISTER 
* 
*         IB(0) = CCC TEST FUNCTION 
*         IB(1) = CCC TEST FUNCTION 
*         IB(2) = NOT USED
*         IB(3) = NOT USED
*         IB(4) = NOT USED
*         IB(5) = NOT USED
*         IB(6) = NOT USED
*         IB(7) = NOT USED
*         IB(10) = P0 - NOT USED
*         IB(11) = P0 - NOT USED
*         IB(13) = P1 - NOT USED
*         IB(14) = P2 - NOT USED
*         IB(15) = P2 - NOT USED
*         IB(16) = P3 - NOT USED
*         IB(17) = P3 - NOT USED
*         IB(20) = P4 - DISABLES
*         IB(21) = P4 - DISABLES
*         IB(22) = P5 - FIRST MODULE SELECTED 
*         IB(23) = P5 - FIRST MODULE SELECTED 
*         IB(24) = P6 - NUMBER OF MODULES TO EXECUTE
*         IB(25) = P6 - NUMBER OF MODULES TO EXECUTE
*         IB(26) = P7 - NOT USED
*         IB(27) = P7 - NOT USED
*         IB(30) = P8 - NOT USED
*         IB(31) = P8 - NOT USED
*         IB(32) = P9 - NOT USED
*         IB(33) = P9 - NOT USED
*         IB(34) = STATE OF TEST
*         IB(35) = STATE OF TEST
*         IB(36) = TYPE OF CCC
*         IB(37) = TYPE OF CCC
*         IB(40) = TEST NAME
*         IB(41) = TEST NAME
*         IB(42) = TEST NAME
*         IB(43) = TEST NAME
*         IB(44) = REVISION LEVEL OF DIAGNOSTIC 
*         IB(45) = REVISION LEVEL OF DIAGNOSTIC 
*         IB(46) = ASSEMBLY DATE
*         IB(47) = ASSEMBLY DATE
*         IB(50) = ASSEMBLY TIME
*         IB(51) = ASSEMBLY TIME
*         IB(52) = MODULE AND CONDITION NUMBER
*         IB(53) = MODULE AND CONDITION NUMBER
*         IB(54) = ERROR CODE 
*         IB(55) = ERROR CODE 
*         IB(56) = ERROR COUNT
*         IB(57) = ERROR COUNT
*         IB(60) = PASS COUNT 
*         IB(61) = PASS COUNT 
*         IB(62) = LAST CALL TO NDI 
*         IB(63) = LAST CALL TO NDI 
*         IB(64) = CCC WORD 5C
*         IB(65) = CCC WORD 5C
*         IB(66) = CURRENT CCC ADDRESS BEING TESTED 
*         IB(67) = CURRENT CCC ADDRESS BEING TESTED 
*         IB(70) = EXPECTED VALUE 
*         IB(71) = EXPECTED VALUE 
*         IB(72) = ACTUAL VALUE 
*         IB(73) = ACTUAL VALUE 
*         IB(74) = ITERATION COUNT
*         IB(75) = ITERATION COUNT
* 
* 
*         SEE BUFFERS USED IN CLM01A MODULE.
* 
*    2.3  SUBMODULES USED 
* 
*         CLM02A - SET OB WITH THE CONTENTS OF THE PARAMETER
*                  REGISTERS, THE ES REGISTER AND THE NDI 
*                  FUNCTION CODE. 
*         CLM02B - DETERMINE THE REASON FOR A STOP CONDITION. 
*         CLM02C - PROVIDE THE INITIAL TEST DISPLAY.
*         CLM02E - READ LOCATIONS 4-F AND ERROR MESSAGE BUFFER
*         CLM03F - DISPLAY LOCATIONS 4-F AND ERROR MESSAGE
* 
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT CCC LOADER AND MONITOR (CLM)
2  FORMAT *A*A*D   EC=*DECD LC=*DECD
3  FORMAT MOD=*DD   COND=*DD   PCNT=*DECD 
4  FORMAT LAST CALL TO NDI FROM ADDRESS *H*H H
5  FORMAT ADDR=*H*H H 
6  FORMAT            ECNT=*DECD      ICNT=*DECD 
7  FORMAT *A*A*D EXECUTING
16 FORMAT E0003 - CHANNEL PARITY ERROR
* 
   EQUATE ACK=6, CSTATUS=0704, FCTE=2 
   EQUATE PBUF=100B, WRT=702, RD8=701, RUN=17B
   EQUATE SBUF=120B, SETADDR=500, STATE=35B 
   EQUATE STER=1, STBM=3
* 
* -----------------TEST-------------------------------------
* 
*                                 *ISSUE PROC. GO/ DISPLAY. 
30 CALL 02C                       *DISP NORMAL RUNNING DISP 
* 
   B6=1                           *SET PGO FUNC INDICATOR 
   CALL 02F 
* 
   B6=0                           *CLEAR PGO FUNC INDICATOR 
32 GOSUB 62                       *INPUT THE CCC TEST STATUS
* 
   CALL 02C                       *CREATE TEST DISPLAY
* 
   B3=ACK 
   CALL 02A                       *PREPARE TO DOWNLOAD PARAM
* 
33 RES, ABT 74
   B1=0                           *ZERO LOOP COUNTER
   GOSUB 60                       *DOWNLOAD PARAM TO CCC
* 
34 GOSUB 62                       *INPUT THE CCC TEST STATUS
*                                 *WAIT FOR NDI ACKNOWLEDGE 
*                                 *FUNCTION (P9) SENT.
   IF(IB(1).EQ.ACK) GOTO 40       *IF CCC RESPONDED 
   GOTO 34 WHILE (B1+1.NE.10D)    *LOOP WAITING FOR RESPONSE
* 
   ERROR 03/01 GOTO 74            *ERROR,CCC DID NOT RESPOND
*                                 *KEEP TEST DISPLAY CURRENT
40 B0=IB(STATE)                   *SAVE TEST STATE
   B14=IB(56).LS.8+IB(57)         *B14=ERROR COUNT
   B15=IB(60).LS.8+IB(61)         *B15=PASS COUNT 
   MSG 3(IB(52)IB(53)B15) TO LINE 4     *MOD,COND,PASS COUNT
   MSG 4(IB(62)IB(63)) TO LINE 5        *LAST P ADDR
   MSG 5(IB(66)IB(67)) TO LINE 10D      *CURRENT TEST ADDR
   MSG 6(B14,IB(75)) TO LINE 11D        *ECNT,ITER. COUNT 
*                                 *PROCESS THE CURRENT STATE
*                                 *OF THE CCC TEST. 
   IF(B0.EQ.0) ERROR 01/02 GOTO 74      *ERR IF NO STATE BIT
   IF(OB(B0+400).EQ.0) GOTO 50          *IF STOP NOT SEL
   IF(B0.NE.STER) GOTO 42               *IF NO ERROR STOP 
*                                 *AN ERROR HAS OCCURRED
   IF(ES.AND.SL.NE.0) GOTO 44     *IF SCOPE LOOPING SET 
42 CALL 02B                       *PROCESS STOP CONDITION 
* 
44 IF(ES.AND.SL.NE.0) MSG 2(B4,B5,IB(52),B14,B15) TO DISPLAY
*         CHECK IF STATE=RUNNING BUT PROCESSOR IS STOPPED.
50 IF(B0.NE.RUN) GOTO 52          *IF TEST HAS STOPPED
   MSG 7(B4,B5,IB(52)) TO LINE 6
   B3=ACK                         *PREPARE TO SEND PASS FUNC
   OB(100)=OB(100)+1              *INCREMENT RUNNING LOOP CTR 
   IF(OB(100).NE.5000) GOTO 33
   CALL 02F 
* 
   GOTO 33
* 
52 B3=FCTE                        *NO ERROR, CONTINUE FUNC
   OB(100)=0                      *CLEAR LOOP COUNTER 
   MSG 7(B4,B5,IB(52)) TO LINE 6
   IF(B0.EQ.STBM) MSG 7(B4,B5,IB(52)) TO PRINT,DISPLAY
54 GOTO 33
*                                 *SEND THE PARAM TO THE CCC
60 OB(501)=PBUF                   *SET UP CCC ADDRESS 
   OB(502)=40B
   OB(401)=DS.AND.1B              *STOP ON ERROR
   OB(402)=DS.AND.40B             *STOP AT BEGINNING OF TEST
   OB(404)=DS.AND.10B             *STOP AT BEGINNING OF COND
   OB(403)=DS.AND.20B             *STOP AT BEGINNING OF MOD 
   OB(405)=DS.AND.100B            *STOP AT END OF TEST
   OB(406)=DS.AND.400B            *STOP AT END OF MODULE
   OB(407)=DS.AND.200B            *STOP AT END OF CONDITION 
   OB(2)=DS.RS.8D 
   OB(3)=DS.AND.377B
   OB(4)=B3.RS.8D 
   OB(5)=B3.AND.377B
   GOSUB 66 
* 
   FUNC WRT, ABT 74 
   OUTB OB(502) WORDS FROM OB(0), ABT 74  *OUTPUT PARAMS
   RETURN 
*                                 *READ THE STATUS BUFFER 
*                                 *(SBUF) IN THE CCC. 
62 OB(501)=SBUF-16B               *SET BA OF TEST STATUS
   OB(502)=37B                    *SET WC OF TEST STATUS
   RES, ABT 74
   GOSUB 66 
* 
   FUNC RD8, ABT 74 
   INB 76B WORDS TO IB(0), ABT 74      *INPUT TEST STATUS 
   RETURN 
*                                 *INITIALIZE THE ADDRESS 
*                                 *AND LENGTH REGISTERS.
66 FUNC SETADDR, ABT 74 
   OUTB 2 WORDS FROM OB(501), ABT 74   *ISSUE BA AND LENGTH 
   FUNC CSTATUS, ABT 74 
   INB 1 WORDS TO IB(0),ABT 74         *INPUT CON. STATUS 
   IF(IB(0).AND.2000.EQ.0) RETURN      *CHANNEL PARITY ERROR
   ERROR 16/02, GOTO 74                *EC=02********** 
* 
* -----------------ABORT PROCESSOR--------------------------
* 
74 B7=B7+1                        *INCREMENT ERROR COUNT
   IF(ES.AND.SL.NE.0) GOTO 76     *IF SCOPING LOOP
   IF(B8.EQ.0) CALL 02C 
* 
   CALL 02E                       *PROCESS THE ERROR
* 
76 IF(B8.EQ.0) ENDSUB GOTO 30     *IF ERROR AT FIRST RES. 
   ENDSUB GOTO 33 
   END 30 
COMPILE                      CLM02 - MONITOR CCC TEST STATUS
   MODULE CLM02A,6000,(31,32,46,47,53,104,105,115)LOCK
***       CLM02A - TEST PARAMETER SUBMODULE 
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         STORE PARAMETERS, TEST CONDITIONS AND TEST FUNCTION 
*         SET BY THE USER IN THE OUTPUT BUFFER.  THIS 
*         DATA WILL LATER BE TRANSFERRED TO THE CCC FROM THE
*         OUTPUT BUFFER.  MODULE DEFAULT SELECT BITS WILL BE
*         SET IF THE USER HAS NOT SELECTED ANY MODULES. 
* 
*    1.2  METHOD
* 
*         1. STORE THE DIAGNOSTIC SWITCH REGISTER CONTENTS AND
*            THE PARAMETER REGISTERS  CONTENTS INTO OB(0-17B).
*         2. STORE THE STOP ENABLES (DIAGNOSTIC REGISTER) IN B0.
*         3. CREATE A BUFFER FROM OB(400-417) FOR USER SELECTED 
*            STOPS.  LOCATION WILL BE NONZERO TO ENABLE STOP AND
*            ZERO TO DISABLE STOP.
*         4. CLEAR THE 2 OUTPUT BUFFER WORDS (OB(501)-OB(502))
*            USED FOR ADDRESS AND LENGTH INFORMATION IN A 
*            SET ADDRESS FUNCTION.
*         5. SET B3 REGISTER TO FUNCTION CODE NECESSARY TO
*            CARRY OUT USERS ORDERS -ETC. RESTART TEST, 
*            TERMINATE TEST . 
*         6. RETURN TO CALLING MODULE.
* 
*    1.3  ERRORS REPORTED - NONE. 
* 
/ 
*    2.0  INTERNAL MODULE DOCUMENTATION 
* 
*    2.1  ENTRY CONDITIONS
* 
*         THE PARAMETER REGISTERS MUST BE SET BY THE USER.
*         THE STOP ENABLES MUST BE SET BY THE USER. 
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         REGISTERS USED -
*         B0  = STOP ENABLES SET BY USER. 
*         B3  = NDI FUNCTION CODE.
* 
*         BUFFERS USED -
*         OB(0-17) - CONTAINS PARAMETER REGISTER CONTENTS.
*         OB(400-417) - CONTAIN STOP ENABLES SET BY THE USER. 
*         OB(501-502) - CLEARED FOR NEXT SET ADDRESS FUNCTION.
*         THE OUTPUT BUFFER NOW CONTAINS THE INFORMATION NECESSARY
*         TO TRANSFER THE PARAMETERS AND STOP ENABLES SET BY THE
*         USER TO THE CCC.  THE FUNCTION THAT MUST BE ISSUED
*         FOLLOWING THIS TRANSFER HAS ALSO BEEN DETERMINED. 
* 
*    2.3  SUBMODULES USED - NONE. 
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT INIT. MONITOR PARAMETERS
2  FORMAT *A*A  RESTARTED 
* 
   EQUATE STBC=10B, STBM=20B, STBT=40, STEC=200B, STEM=400
   EQUATE STET=100B, STER=1, ACK=6
* 
* -----------------INITIALIZATION---------------------------
* 
*                                 *SET PARAM FOR DOWNLOADING
*                                 *INTO THE CCC MEMORY. 
30 MSG 1 TO DISPLAY               *DISPLAY INITIALIZING MSG 
   OB(0) = 0
   OB(1) = 0
   OB(2) = DS.RS.8D 
   OB(3) = DS.AND.377B
   OB(4) = 0
   OB(5) = 0
   OB(6) = 0
   OB(7) = 0
   OB(10) = 0 
   OB(11) = 1 
   OB(12) = 0 
   OB(13) = 0 
   OB(14) =P0.RS.8D 
   OB(15) = P0.AND.377
   OB(16) = P1.RS.8D
   OB(17) = P1.AND.377
   OB(20) = P2.RS.8D
   OB(21) = P2.AND.377
   OB(22) = P3.RS.8D
   OB(23) = P3.AND.377
   OB(24) = P4.RS.8D
   OB(25) = P4.AND.377
   OB(26) = P5.RS.8D
   OB(27) = P5.AND.377
   OB(30) = P6.RS.8D
   OB(31) = P6.AND.377
   OB(32) = P7.RS.8D
   OB(33) = P7.AND.377
   OB(34) = P8.RS.8D
   OB(35) = P8.AND.377
   OB(36) = P9.RS.8D
   OB(37) = P9.AND.377
* 
* -----------------TEST-------------------------------------
* 
*                                 *FORM MASK TABLE FOR EVERY
*                                 *TEST STOP CONDITION
   B0=DS                          *STOP ENABLES 
   OB(400)=0                      *RESERVED 
   OB(401)=B0.AND.STER            *STOP ON ERROR
   OB(402)=B0.AND.STBT            *STOP AT BEGINNING OF TEST
   OB(404)=B0.AND.STBC            *STOP AT BEGINNING OF COND
   OB(403)=B0.AND.STBM            *STOP AT BEGINNING OF MOD 
   OB(405)=B0.AND.STET            *STOP AT END OF TEST
   OB(406)=B0.AND.STEM            *STOP AT END OF MODULE
   OB(407)=B0.AND.STEC            *STOP AT END OF CONDITION 
   OB(410)=1                      *STOP AT BREAKPOINT 
   OB(411)=0                      *STOPPED AT NOOP
   OB(412)=1                      *STOPPED WAIT USER INTERV.
   OB(413)=1                      *STOPPED AT REQ OF USER 
   OB(414)=0                      *STOPPED WAIT FOR CONTINUE
   OB(415)=1                      *TEST TERMINATED
   OB(416)=1                      *STOPPED ON UNEXP INTERRT 
   OB(417)=0                      *TEST RUNNING 
*                                 *EXIT THE MODULE. 
   EXIT 
* 
   END 30 
COMPILE                      CLM02A - PARAMETER BUFFER AND TEST STOP MAS
   MODULE CLM02B,6000,(31,32,46,47,53,104,105,115)LOCK
***       CLM02B - TEST STOP SUBMODULE
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         CLM02B WILL BE CALLED IF THE TEST HAS STOPPED AND 
*         THIS STOP HAS BEEN REQUESTED BY THE USER OR A STOP
*         ON ERROR HAS OCCURRED.  CLM02B WILL THEN INFORM THE 
*         USER WHY THE STOP HAS OCCURRED AND IF THE STOP IS 
*         DUE TO AN ERROR. THE ACTUAL AND EXPECTED DATA WILL ALSO 
*         BE DISPLAYED. 
* 
*    1.2  METHOD
* 
*         1. MASK OFF EACH STATE BIT WITH ITS CORRESPONDING STOP
*            SELECT BIT.  IF THE USER HAS SELECTED A STOP,
*            THE MASKING PROCESS WILL INDICATE THIS CONDITION 
*            AND A MESSAGE WILL BE DISPLAYED TO INFORM THE
*            USER WHICH STOP ENABLE HAS STOPPED THE TEST. 
*         2. IF NO OTHER STOP HAS BEEN SET, A STOP ON ERROR IS
*            INDICATED AND THE ERROR CODE, ACTUAL AND EXPECTED
*            AND ACTUAL RESULTS ARE DISPLAYED FOR THE USER. 
*         3. IF THE TEST IS TERMINATED AND RM HAS BEEN SET, 
*            AN ERROR WILL BE REPORTED. 
*         4. RETURN TO THE CALLING MODULE.
* 
*    1.3  ERRORS REPORTED 
* 
*         *A*A*D STOPPED ON ERROR 
*         *A*A*D STOPPED AT UNEXPECTED INTERRUPT
*         *A*A*D UNKNOWN STOP DETECTED
* 
/    2.0  INTERNAL DOCUMENTATION
* 
*    2.1  ENTRY CONDITION 
* 
*         A TEST STOP MUST HAVE PREVIOUSLY OCCURRED TO ENTER
*         CLM02B. 
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         B0  = NDI STATE STATUS. 
*         B1  = MESSAGE INDEX.
*         B7  = ERROR COUNTER.
* 
*         BUFFERS USED - NONE.
* 
*    2.3  SUBMODULES USED 
* 
*         CLM02E - CALLED TO REPORT AN ERROR. 
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT *A*A*D STOPPED ON ERROR 
2  FORMAT *A*A*D STOPPED BEG. MODULE
3  FORMAT *A*A*D STOPPED BEG.CONDITION
4  FORMAT *A*A*D STOPPED END MODULE 
5  FORMAT *A*A*D STOPPED END CONDITION
6  FORMAT *A*A*D BREAKPOINT STOP
7  FORMAT *A*A*D STOPPED ON NOOP
10 FORMAT *A*A*D STOPPED FOR USER INTERVENTION
11 FORMAT *A*A*D STOPPED AT REQUEST OF USER 
12 FORMAT *A*A   STOPPED BEG. TEST
13 FORMAT *A*A   STOPPED END TEST 
14 FORMAT *A*A*D TERMINATED 
15 FORMAT *A*A*D STOPPED WAITING FOR CONTINUE 
16 FORMAT *A*A*D STOPPED AT UNEXPECTED INTERRUPT
17 FORMAT *A*A*D UNKNOWN STOP DETECTED
22 FORMAT 
23 FORMAT PAUSE - CLEAR RM TO TERMINATE TEST
24 FORMAT PAUSE - AWAITING USER GO
* 
   EQUATE STER=1, STBT=2, STBM=3, STBC=4, STET=5, STEM=6
   EQUATE STEC=7, STBP=10, STNO=11, STOI=12, STRO=13
   EQUATE STATE=35, STWC=14,STTT=15,STUI=16 
* 
* -----------------TEST-------------------------------------
* 
*                                 *DETERMINE THE REASON WHY 
*                                 *THE TEST HAS STOPPED.
30 B0=IB(STATE)                   *NDI STATUS WORD
   B1=1                           *MESSAGE NUMBER 
   IF(B0.EQ.STER) GOTO 62         *IF STOPPED ON ERROR
   B1=2                           *MESSAGE NUMBER 
   IF(B0.EQ.STBM) GOTO 62         *IF BEGINNING OF MOD STOP 
   B1=3                           *MESSAGE NUMBER 
   IF(B0.EQ.STBC) GOTO 62         *IF BEGINNING OF COND STOP
   B1=4                           *MESSAGE NUMBER 
   IF(B0.EQ.STEM) GOTO 62         *IF END OF MODULE STOP
   B1=5                           *MESSAGE NUMBER 
   IF(B0.EQ.STEC) GOTO 62         *IF END OF CONDITION STOP 
   B1=6                           *MESSAGE NUMBER 
   IF (B0.EQ.STBP) GOTO 62        *IF BREAKPOINT STOP 
   B1=12                          *MESSAGE NUMBER 
   IF(B0.EQ.STBT) GOTO 60         *IF BEGINNING OF TEST STOP
   B1=13                          *MESSAGE NUMBER 
   IF(B0.EQ.STET) GOTO 60         *IF END OF TEST STOP
   B1=14                          *MESSAGE NUMBER 
   IF(B0.EQ.STTT) GOTO 74         *IF TERMINATED
   B1=7 
   IF(B0.EQ.STNO) GOTO 62         *IF NOOP
   B1=10
   IF(B0.EQ.STOI) GOTO 62         *IF USER INTERVENTION 
   B1=11
   IF(B0.EQ.STRO) GOTO 62         *STOPPED REQUEST OF USER
   B1=15
   IF(B0.EQ.STWC) GOTO 62         *STOPPED WAIT FOR CONTINUE
   B1=16
   IF(B0.EQ.STUI) GOTO 62         *STOPPED AT UNEXP INTERRT 
   B1=17
   GOTO 74
*                                 *PROCESS ALL STOPS. 
60 MSG B1(B4,B5) TO LINE 6        *DISPLAY STOP MESSAGE 
   MSG B1(B4,B5) TO PRINT,DISPLAY 
   GOTO 64
* 
62 MSG B1(B4,B5,IB(52)) TO LINE 6  *DISPLAY STOP MESSAGE
   MSG B1(B4,B5,IB(52)) TO PRINT,DISPLAY
   IF(B0.NE.STER) GOTO 64 
   B7=B7+1
   EXIT TO 02E                    *IF TEST STOPPED ON ERROR 
* 
   EXIT 
* 
64 PICTURE
   MSG 24 TO PRINT,DISPLAY
   PAUSE                          *WAIT FOR USER GO 
   EXIT 
*                                 *PROC A TEST TERM STATUS
74 IF(ES.AND.RM.EQ.0) GOTO 76 
   MSG 23 TO LINE 8D              *REPORT RM SET ILLEGALLY
   MSG 22 TO LINE 9D
   MSG 23 TO DISPLAY
   PAUSE
   GOTO 74
* 
76 MSG B1(B4,B5,IB(52)) TO LINE 6  *DISPLAY STOP MESSAGE
   MSG B1(B4,B5) TO PRINT,DISPLAY 
   END 30                         *END THE TEST 
COMPILE                      CLM02B - REPORTS TEST STOPS
   MODULE CLM02C,6000,(31,32,46,47,53,104,105,115)LOCK
***       CLM02C - TEST STATUS SUBMODULE
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         CLM02C WILL INITIALLY BE CALLED BY CLM02 TO DISPLAY 
*         THE TEST STATUS.  FROM THEN ON DURING TEST EXECUTION, 
*         CLM02 AND CLM02B WILL UPDATE THE STATUS DISPLAY.
* 
*    1.2  METHOD
* 
*         1.  THE STATUS OF THE TEST WILL BE DISPLAYED IN LINES 
*             1-15D.
* 
*    1.3  ERRORS REPORTED - NONE. 
* 
/    2.0  INTERNAL MODULE DOCUMENTATION 
* 
*    2.1  ENTRY CONDITIONS
* 
*         CLM02 WILL CALL CLM02C. 
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         B8  = DISPLAY INITIALIZATION FLAG.
*         B4  = TEST NAME.
*         B5  = TEST NAME.
*         B11 = TEMPORARY STORAGE.
*         B12 = TEMPORARY STORAGE.
*         B13 = TEMPORARY STORAGE.
*         B14 = TEMPORARY STORAGE.
*         B15 = TEMPORARY STORAGE.
* 
*         BUFFERS USED -
*         IB(0-IB(43) - HOLDS TEST STATUS FROM THE CCC. 
* 
*    2.3  SUBMODULES USED - NONE. 
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT CCC LOADER AND MONITOR(CLM) 
2  FORMAT DIAGNOSTIC *A*A    REVISION *OB 
4  FORMAT ASSEMBLED ON *D/*D/*D  AT *D.*D 
5  FORMAT MOD=*DD   COND=*DD   PCNT=*DECD 
6  FORMAT LAST CALL TO NDI FROM ADDRESS *H*H H
7  FORMAT                            ICNT=*DECD 
* 
* -----------------TEST-------------------------------------
* 
*                                 *DISP NORMAL RUNNING DISP 
30 MSG 1 TO LINE 0
   B4=IB(41)                      *SAVE UP BITS OF TEST NAME
   B5=IB(42).LS.6+IB(43)          *SAVE LO BITS OF TEST NAME
   B12=IB(45).AND.377 
   MSG 2 (B4,B5,B12) TO LINE 1    *TEST NAME,REVISION 
   B11=IB(46).RS.1                *YEAR 
   B12=IB(46).AND.1.LS.3          *MONTH
   B12=IB(47).RS.5+B12            *MONTH
   B13=IB(47).AND.37              *DAY
   B14=IB(50).LS.2                *HOUR 
   B14=IB(51).RS.6+B14            *HOUR 
   B15=IB(51).AND.77              *MINUTE 
   MSG 4(B11,B12,B13,B14,B15) TO LINE 3 
   B12=IB(60).LS.8+IB(61) 
   MSG 5 (IB(52)IB(53)B12) TO LINE 4    *MOD/COND/PASS CNT
   MSG 6(IB(62)IB(63)) TO LINE 5  *LAST P ADDR. 
   MSG 7 (IB(75)) TO LINE 11D     *ITERATION COUNT
   B8=1                           *SET DISPLAY INITIAL FLAG 
   EXIT 
* 
   END 30 
COMPILE                      CLM02C - DISP NORM TEST STATUS 
   MODULE CLM02E,6000,(31,32,46,47,53,104,105,115)LOCK
***       CLM02E - TEST ERROR SUBMODULE 
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         CLM02E WILL READ ADDRESSES  4-F OF CCC
*         MEMORY INTO PP MEMORY.  THE MESSAGE BUFFER OF 
*         THE CCC WILL ALSO BE READ INTO PP MEMORY FOR
*         DISPLAY.
* 
*    1.2  METHOD
* 
*         1. READ ADDRESS 4-F  OF CCC MEMORY INTO PP. 
*         2. READ THE MESSAGE BUFFER OF THE CCC MEMORY
*            INTO THE PP. 
* 
*    1.3  ERRORS REPORTED 
* 
*         E002 - CHANNEL PARITY ERROR 
* 
/    2.0  INTERNAL MODULE DOCUMENTATION 
* 
*    2.1  ENTRY CONDITIONS
* 
*         CLM02E WILL BE ENTERED UPON ERROR DETECTION.
* 
*    2.1  REGISTER AND BUFFER USAGE 
* 
*         B7  = ERROR COUNTER.
* 
*         EM,EC,WT - STANDARD USAGE 
* 
*         BUFFERS USED -
*         TO SET THE ADDRESS AND LENGTH REGISTERS IN THE CCC THE
*            FOLLOWING LOCATIONS ARE USED IN THE PP_
*         OB(501) = CCC ADDRESS REGISTER
*         OB(502) = CCC LENGTH REGISTER 
*         CLM02E WILL RETURN TO CALLING MODULE ON 
*            COMMAND ABORT ERROR. 
* 
*    2.3  SUBMODULES USED - NONE. 
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT CCC LOADER AND MONITOR(CLM) 
2  FORMAT CLM02 - CCC TEST MONITOR
3  FORMAT E0002 - CHANNEL PARITY ERROR
4  FORMAT ERROR *A*A*A*A*A*A*A*A
5  FORMAT       *A*A*A*A*A*A
6  FORMAT EC=*OCTB   ECNT=*DECD      ICNT=*DECD 
7  FORMAT ADDR=*H*H H   EXP=*H*H H   ACT=*H*H H 
10 FORMAT --------------------------------------
11 FORMAT PAUSE - AWAITING USER GO
* 
   EQUATE CSTATUS=704,SETADDR=500,RD8=701,MSGB=160B 
* 
* -----------------TEST-------------------------------------
* 
*                                 *READ ERROR MESSAGE BUFFER
30 RES, ABT 74
   IF(EC.GE.4000) GOTO 74 
   OB(501)=MSGB                   *SET CCC ADDR TO MSG. BUFF
   OB(502)=16B
   GOSUB 60 
* 
   FUNC RD8, ABT 74               *READ MESSAGE BUFFER
   INB 34B WORDS TO IB(200), ABT 74 
   IB(200)=IB(200).LS.6+IB(201) 
   IB(201)=IB(202).LS.6+IB(203) 
   IB(202)=IB(204).LS.6+IB(205) 
   IB(203)=IB(206).LS.6+IB(207) 
   IB(204)=IB(210).LS.6+IB(211) 
   IB(205)=IB(212).LS.6+IB(213) 
   IB(206)=IB(214).LS.6+IB(215) 
   IB(207)=IB(216).LS.6+IB(217) 
   IB(210)=IB(220).LS.6+IB(221) 
   IB(211)=IB(222).LS.6+IB(223) 
   IB(212)=IB(224).LS.6+IB(225) 
   IB(213)=IB(226).LS.6+IB(227) 
   IB(214)=IB(230).LS.6+IB(231) 
   IB(215)=IB(232).LS.6+IB(233) 
   IB(216)=IB(234).LS.6+IB(235) 
   IB(217)=IB(236).LS.6+IB(237) 
   IB(220)=IB(240).LS.6+IB(241) 
   IB(221)=IB(242).LS.6+IB(243) 
   IB(222)=IB(244).LS.6+IB(245) 
   IB(223)=IB(246).LS.6+IB(247) 
   IB(224)=IB(250).LS.6+IB(251) 
   IB(225)=IB(252).LS.6+IB(253) 
   IB(226)=IB(254).LS.6+IB(255) 
   IB(227)=IB(256).LS.6+IB(257) 
   IB(230)=IB(260).LS.6+IB(261) 
   IB(231)=IB(262).LS.6+IB(263) 
   IB(232)=IB(264).LS.6+IB(265) 
   IB(233)=IB(266).LS.6+IB(267) 
   MSG 4 10B WORDS FROM IB(200) TO LINE 8D
   MSG 5 6 WORDS FROM IB(210) TO LINE 9D
*                                 *CURRENT ADDR/EXPECTED
*                                 *AND ACTUAL RESULTS.
   MSG 7(IB(66)IB(67)IB(70)IB(71)IB(72)IB(73)) TO LINE 10D
   B12=IB(54).LS.8.+.IB(55)       *ERROR CODE 
   B13=IB(56).LS.8.+.IB(57)       *ERROR COUNT
   MSG 6(B12,B13,IB(75)) TO LINE 11D
   PICTURE
   MSG 11 TO PRINT,DISPLAY
   PAUSE
   MSG 10 TO PRINT
   EXIT TO 02F
*                                 *SET ADDR AND LENGTH REG. 
60 FUNC SETADDR, ABT 74 
   OUTB 2 WORDS FROM OB(501), ABT 74  *OUTPUT ADDR./LENGTH
   FUNC CSTATUS, ABT 74           *CHECK CONTROLLER STATUS
   INB 1 WORDS TO IB(0),ABT 74
   IF(IB(0).AND.2000.EQ.0) RETURN  *IF CHANNEL PARITY ERROR 
   ERROR 03/02, GOTO 74           *EC=02********* 
* 
* -----------------ERROR PROCESSOR--------------------------
* 
74 B7=B7+1                   *INCREMENT ERROR COUNT 
   MSG EM TO LINE 8D
   PICTURE
   HALT 
   MSG 10 TO PRINT
   ENDSUB 
   EXIT 
* 
   END 30 
COMPILE                      CLM02E - REPORTS ERRORS
   MODULE CLM02F,6000,(31,32,46,47,53,104,105,115)LOCK
***       CLM02F - HARDWARE ERROR DISPLAY SUBMODULE 
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         CLM02F WILL BE CALLED TO EXECUTE A PROCESSOR
*         GO FUNCTION AND DISPLAY 4-F OF THE
*         CCC MEMORY IF THE PROCESSOR IS STOPPED. 
* 
*    1.2  METHOD
* 
*         1.IF A TEST HAS JUST BEEN LOADED, ISSUE A 
*           PROCESSOR GO FUNCTION TO START THE CCC PROCESSOR. 
*           IF THE PROCESSOR DOES NOT BEGIN RUNNING, DISPLAY
*           LOCATION 4-F AND STOP ON ERROR. 
*           WHEN THE USER ENTERS A GO, CONTINUE RUNNING 
*           THE MONITOR EVEN THOUGH THE PROCESSOR STOPPED 
*           BIT IS SET. 
*           IF THE PROCESSOR IS RUNNING, EXIT THE MODULE. 
* 
*         2.AFTER A TEST ERROR HAS OCCURRED, CHECK IF THE 
*           PROCESSOR IS RUNNING. IF THE PROCESSOR IS NOT 
*           RUNNING, DISPLAY LOCATIONS 4-F AND
*           STOP ON AN ERROR.  WHEN THE USER ENTERS 
*           A GO, EXECUTE A PROCESSOR GO FUNCTION.  IF
*           THE PROCESSOR DOES NOT BEGIN RUNNING, DISPLAY 
*           LOCATIONS 4-F .  WHEN THE USER
*           ENTERS A GO, CONTINUE RUNNING THE MONITOR EVEN
*           THROUGH THE PROCESSOR STOPPED BIT IS SET. 
*           IF THE PROCESSOR IS RUNNING, EXIT THE MODULE. 
* 
*    1.3  ERRORS REPORTED 
* 
*           CCC PROCESSOR IS NOT RUNNING
*           ENTER GO TO CONTINUE AT YOUR OWN RISK 
*           E0002 - CHANNEL PARITY ERROR
* 
/    2.0  INTERNAL MODULE DOCUMENTATION 
* 
*    2.1  ENTRY CONDITIONS
* 
*           B6,PROCESSOR GO FUNCTION INDICATOR, MUST BE SET 
*           ON ENTRY IF A PROCESSOR GO WAS JUST EXECUTED
*           TO DETERMINE IF THE PROCESSOR SHOULD OR SHOULD
*           NOT BE RUNNING. 
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         B7  = ERROR COUNTER.
*         B12 = WORKING REGISTER. 
* 
*         EM,EC,WT - STANDARD USAGE 
* 
*         BUFFERS USED -
*         TO SET THE ADDRESS AND LENGTH REGISTERS IN THE CCC THE
*            FOLLOWING LOCATIONS ARE USED IN THE PP_
*         OB(501) = CCC ADDRESS REGISTER
*         OB(502) = CCC LENGTH REGISTER 
* 
*    2.3  SUBMODULES USED - NONE. 
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT    CONTENTS OF LOCATIONS 4-F (REGISTER DISPLAY) 
2  FORMAT   4=*H*H H   5=*H*H H    6=*H*H H    7=*H*H H 
3  FORMAT   8=*H*H H   9=*H*H H    A=*H*H H    B=*H*H H 
4  FORMAT   C=*H*H H   D=*H*H H    E=*H*H H    F=*H*H H 
7  FORMAT HARDWARE STATUS=*OCTB 
10 FORMAT 
22 FORMAT   CCC PROCESSOR IS NOT RUNNING
23 FORMAT   ENTER GO TO CONTINUE AT YOUR OWN RISK 
24 FORMAT E0002 - CHANNEL PARITY ERROR
25 FORMAT ----------------------------------------
* 
   EQUATE CSTATUS=704, SETADDR=500
   EQUATE RD8=0701, PGO=720, MSGB=160B
* 
* ------------------SUBROUTINES-----------------------------
*                                 *TO START PROC. IF STOPPED. 
30 RES, ABT 74
   IF(B6.EQ.0) GOTO 32
   GOSUB 40                       *ISSUE PGO AFTER TEST LOAD
* 
   IF(IB(0).AND.2.EQ.2) EXIT      *IF PROCESSOR RUNNING 
   GOSUB 34                       *IF PROCESSOR NOT RUNNING 
* 
   GOTO 74
* 
32 GOSUB 42 
* 
   GOSUB 64 
* 
   IF(IB(0).AND.2.EQ.2) EXIT      *IF PROCESSOR RUNNING 
   GOSUB 34 
   MSG 22 TO PRINT,DISPLAY
   MSG 23 TO PRINT DISPLAY
   PAUSE
   RES, ABT 74
   GOSUB 64 
* 
   GOSUB 40                       *ISSUE PGO FUNC AFTER LOAD
* 
   IF(IB(0).AND.2.EQ.2) EXIT      *IF PROCESSOR RUNNING 
   GOSUB 34                       *IF PROCESSOR NOT RUNNING 
* 
   GOTO 74
*                                 *TO HANDLE ERROR REPORTING
*                                 *DISP LOC 4-F OF CCC MEM
34 MSG 7(IB(0)) TO LINE 2         *DISPLAY HARDWARE STATUS
   OB(501)=4                      *SET ADDRESS
   OB(502)=14B                    *SET LENGTH 
   GOSUB 60 
  
   FUNC RD8, ABT 74 
   INB 30B WORDS TO IB(300), ABT 74   *INPUT WORDS 4-F
   MSG 1 TO LINE 12D
   MSG 2 10B WORDS FROM IB(300) TO LINE 13D 
   MSG 3 10B WORDS FROM IB(310) TO LINE 14D 
   MSG 4 10B WORDS FROM IB(320) TO LINE 15D 
   MSG 22 TO LINE 8D
   MSG 23 TO LINE 9D
   RETURN 
*                                 *ISSUE A PROC GO FUNCTION 
*                                 *AND INPUT HARDWARE STATUS
40 FUNC PGO, ABT 74 
42 FUNC CSTATUS, ABT 74 
   INB 1 WORDS TO IB(0), ABT 74   *INPUT HARDWARE STATUS
   RETURN 
*                                 *SET ADDR/LGTH REG. IN CCC
60 FUNC SETADDR, ABT 74 
   OUTB 2 WORDS FROM OB(501), ABT 74  *OUTPUT ADDR./LENGTH
   FUNC CSTATUS, ABT 74 
   INB 1 WORDS TO IB(1), ABT 74   *INPUT HARDWARE STATUS
   IF(IB(1).AND.2000.EQ.0) RETURN  *EC=02*********
   ERROR 24/02
   MSG EM TO LINE 8D
   GOTO 74
* 
64 MSG 10 TO LINE 2 
   MSG 10 TO LINE 8D
   MSG 10 TO LINE 9D
   MSG 10 TO LINE 12D 
   MSG 10 TO LINE 13D 
   MSG 10 TO LINE 14D 
   MSG 10 TO LINE 15D 
   MSG 10 TO LINE 16D 
   MSG 10 TO LINE 17D 
   MSG 10 TO LINE 18D 
   MSG 10 TO LINE 19D 
   MSG 10 TO LINE 20D 
   RETURN 
* 
* -----------------ERROR PROCESSOR--------------------------
* 
74 B7=B7+1                        *INCREMENT ERROR COUNT
76 PICTURE
   HALT 
   MSG 25 TO PRINT
   GOSUB 64 
* 
   ENDSUB 
   EXIT 
* 
   END 30 
COMPILE                      CLM02F - STARTS CCC
   MODULE CLM20,6000(104,105)LOCK 
***       CLM20 - INVOKE MASSTOR DATA CHECK TEST
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
*         ----------------------------- 
* 
*    1.1  PURPOSE-
* 
*         INVOKE THE MASSTOR CW FUNCTION  04 (DATA PATH CHECK TEST)  IN 
*         THE CCC.  MONITOR THE RESULTS AND REPORT ANY ERROR. 
* 
*    1.2  METHOD- 
* 
*         1.  DISPLAY THE RUNNING MESSAGE FOR THE MODULE. 
*         2.  RESERVE THE CHANNEL TO THE CCC. 
*         3.  ISSUE A MASTER CLEAR (414 FUNC) TO THE CCC. 
*         4.  GET A GENERAL STATUS (012 FUNC) AND CHECK  FOR 0XXX.  EI- 
*             THER AN ABORT OR A 4XXX STATUS INDICATES AN ABNORMAL CON- 
*             DITION.   POST THE APPROPRIATE MESSAGE,  PAUSE, AND  WAIT 
*             OPERATOR ACTION.
*         5.  DISPLAY  THE RUNNING  MESSAGE IF SCOPING LOOP IS  NOT SE- 
*             LECTED, OR THE REPEAT  CONDITION MESSAGE  IF SCOPING LOOP 
*             IS SELECTED.
*         6.  FUNCTION  THE DATA CHECK TEST (04 FUNC)  TO THE CCC  CON- 
*             TROLWARE. 
*         7.  DISPLAY  THE  RUNNING  MESSAGE  IF  SCOPING  LOOP  IS NOT 
*             SELECTED, OR THE REPEAT CONDITION MESSAGE IF SCOPING LOOP 
*             IS SELECTED.
*         8.  RESERVE THE CHANNEL TO THE CCC. 
*         9. CHECK THE STATUS OF THE CCC. LOOP BACK TO STEP 8 FOR 3 
*            MINUTES MAXIMUM IF DC=104 AND 5 MINUTES MAXIMUM IF THE 
*            DC=105 AWAITING STATUS. REPORT AN ERROR IF NO STATUS IS
*            RECEIVED OR IF THE RECEIVED STATUS IS WRONG. 
*        10.  IF REPEAT CONDITION IS SELECTED,REPEAT STEPS 4 THROUGH 10 
*        11.  IF REPEAT MODULE IS SELECTED, REPEAT STEPS 1 THROUGH 11.
*        12.  IF  ANY ERRORS WERE DETECTED DURING  THE EXECUTION OF THE 
*             MODULE, SEND A MESSAGE INDICATING THE  NUMBER  OF  ERRORS 
*             DETECTED BY THE MODULE TO DISPLAY, PRINT, AND DAYFILE.
*        13.  EXIT THE MODULE.
* 
*    1.3  ERRORS REPORTED 
* 
*         CLM20 - NO CNTRLWARE OR IN-LINE FAILURE 
*         CLM20 STATUS ERROR = *OCTB *OCTB *OCTB
*         CLM20 MASSTOR PATH CHECK FAILURE(S) = *DECD 
*         CLM20 NO RESPONSE WITHIN 3 MIN. DC=104
*         CLM20 NO RESPONSE WITHIN 5 MIN. DC=105
* 
/    2.0  INTERNAL MODULE DOCUMENTATION 
* 
*    2.1  ENTRY CONDITIONS
* 
*         NONE
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         B10 - LOOP COUNTER FOR STATUS 
*         B11 - NUMBER OF PRODUCT OVERLAY COMMAND ABORTED.
*         B14 - MODULE ERROR COUNT. 
*         B15 - MODULE PASS COUNT.
*         BA  - DATA BUFFER BASE ADDRESS. 
*         EA  - STANDARD USAGE. 
*         EC  - STANDARD USAGE. 
*         EM  - STANDARD USAGE. 
*         ES  - STANDARD USAGE. 
* 
*         IB(000) TO IB(002) - CCC STATUS 
* 
*    2.3  SUBMODULES USED 
* 
*         NONE
* 
* -----------------DATA DIVISION----------------------------
* 
0  FORMAT CLM20 - MASSTOR DATA CHECK
1  FORMAT CLM20 - NO CNTLWARE OR IN-LINE FAILURE
2  FORMAT CLM20 - EC=*DECD, LC=*DECD
3  FORMAT CLM20 STATUS ERROR = *OCTB *OCTB *OCTB
4  FORMAT CLM20 MASSTOR PATH CHECK FAILURE(S)=*DECD 
5  FORMAT CLM20 ABORTED ON FUNCTION 
6  FORMAT CLM20 ABORTED ON STATUS COMMAND 
7  FORMAT CLM20 ABORTED ON .RES. COMMAND
10 FORMAT CLM20 NO RESPONSE WITHIN 3 MIN. 
11 FORMAT  LAST FUNCTION = *OCTB
12 FORMAT --------------------------------------------------
13 FORMAT CLM20 DATA CHECK TEST RUNNING *DE SEC 
14 FORMAT CLM20 NO RESPONSE WITHIN 5 MIN. 
* 
*         EQUATES FOR THE MODULE. 
* 
   EQUATE GSTATUS=012, MCLR=414, RIT=04 
* 
* -----------------INITIALIZATION---------------------------
* 
*         DISPLAY MODULE RUNNING MESSAGE. 
* 
30 MSG 0 TO DISPLAY,PRINT    *DISPLAY RUNNING MESSAGE 
   B10=0
* 
* 
* -----------------TEST-------------------------------------
* 
32 GOSUB 70                  *RESERVE CCC CHANNEL 
* 
   B11=5
   TIMEOUT TYPEB=500000 USEC  *ALLOW IN-LINES 500MS 
   FUNC MCLR, ABT 74          *ISSUE MASTER CLEAR 
   TIMEOUT TYPEB=262000 USEC  *RETURN TIMEOUT TO NORMAL 
   FUNC GSTATUS, ABT 34      *CHECK FOR STATUS = 0XXX 
   B11=6
   INB 1 WORDS TO IB(0), ABT 74     *READ STATUS
   IF(IB(0).AND 4000.EQ.0) GOTO 36  *CONTINUE STATUS OK 
   B14=B14+1                 *UPDATE ERROR COUNT
   IF (ES.AND.SL.NE.0)GOTO 32 
   MSG 3(IB(0),IB(1),IB(2)) TO LINE 4  *POST BAD STATUS 
34 MSG 0 TO LINE 0
   MSG 1 TO LINE 2           *POST CW NOT LOADED
   HALT 
   GOTO 50                   *GO TO END OF MODULE 
* 
*            FUNCTION INTEGRITY TEST AND OUTPUT EQ NO.
* 
36 B11=5                     *FUNCTION NUMBER COMMAND 
   FUNC RIT, ABT 74          *FUNC RUN INTEGRITY TEST 
   GOSUB 52                  *CHECK FOR STATUS = 0
* 
* -----------------REPEAT/EXIT------------------------------
* 
*         PROCESS REPEAT CONDITION. 
* 
42 IF(ES.AND.RC.EQ.0) GOTO 50  *IF REPEAT CONDITION OFF 
* 
   IF(B14.GE.B4) B4=B14+20B  *INCR MAX ERR. CNT.
   GOTO 32                   *GO TO REPEAT THE CONDITION
* 
* 
*         PROCESS REPEAT MODULE.
* 
50 IF(ES.AND.RM.NE.0)GOTO 30   *IF REPEAT MODULE SELECTED 
* 
   IF(B14.NE.0)MSG 4(B14) TO DISPLAY,PRINT,DAYFILE
   MSG 12 TO PRINT
   GOTO 76                   *EXIT THE MODULE 
* 
* --------------------SUBROUTINES---------------------------
* 
*         OBTAIN GENERAL STATUS 
* 
52 GOSUB 70                  *RESERVE CCC CHANNEL 
   MSG 13(B10) TO LINE 4     *DISPLAY SECOND COUNT
   DELAY 900D MSEC
   B11=5                     *STATUS COMMAND NUMBER 
   FUNC GSTATUS, ABT 74      *FUNCTION CCC FOR STATUS 
   B11=6                     *STATUS COMMAND NUMBER 
   IF(DC.EQ.105) GOTO 53     *STATUS 2 WORDS IF DC=105
   STATUS 3 WORDS TO IB(0), ABT 56  *READ STATUS
   GOTO 55                   *CHECK STATUS
53 STATUS 2 WORDS TO IB(0), ABT 56  *READ STATUS
55 IF(IB(0).AND.4000.NE.0) GOTO 60  *IF STAT. ERR.
   BLANK
   RETURN                    *STATUS IS OK
56 B10=B10+1
   B4 = 180D                 *SET COUNT FOR STATUS
   IF(DC.EQ.105) B4 = 260D   *SET COUNT FOR MASSTOR CSS 
   IF(B10.LT.B4) GOTO 52     *LOOP AWAITING STATUS
   IF(DC.EQ.104) MSG 10 TO LINE 2  *TIME OUT MESSAGE
   IF(DC.EQ.105) MSG 14 TO LINE 2  *TIME OUT MESSAGE
60 B14=B14+1                 *UPDATE ERROR COUNT
   IF(ES.AND.SL.NE.0) RETURN  *IF SCOPING LOOP ON 
   MSG 3 (IB(0),IB(1),IB(2)) TO LINE 4  *POST STATUS
   MSG 4 (B14) TO LINE 6     *POST FAILURE MSG
   PICTURE
   HALT 
   MSG 12 TO PRINT
   BLANK
   GOTO 42                   *CHECK END OF CONDITION
* 
*         POST RUNNING MESSAGE AND RESERVE CCC CHANNEL
* 
70 B15=B15+1                 *UPDATE PASS COUNT 
   IF(ES.AND.SL.EQ.0)MSG 0 TO DISPLAY 
   IF(ES.AND.SL.NE.0)MSG 2(B14,B15) TO DISPLAY
   B11= 7                    *RES COMMAND NUMBER
   RES,ABT 74                *RESERVE CCC CHANNEL 
   RETURN                    *EXIT THE SUBROUTINE 
* 
*         PROCESS COMMAND ABORTS IN THE MODULE
* 
74 B14=B14+1                 *UPDATE ERROR COUNT
   IF(ES.AND.SL.NE.0) GOTO 75  *EXIT SUBROUTINE 
* 
*             BUILD THE ERROR DISPLAY 
* 
   MSG 0 TO LINE 0           *TEST TITLE MESSAGE
   MSG 11 (LF,WT) TO LINE 4  *LAST FUNCTION MESSAGE 
   MSG EM TO LINE 6          *ERROR DESCRIPTION MESSAGE 
* 
*         POST COMMAND ABORTED AND REPORT THE ERROR 
* 
   MSG B11 TO LINE 3         *COMMAND ABORTED MESSAGE 
   PICTURE
   HALT                      *REPORT THE ERROR
   MSG 12 TO PRINT
   BLANK                     *CLEAR THE DISPLAY BUFFER
* 
75 ENDSUB GOTO 42            *GO TO END OF THE CONDITION
* 
76 END 30                    *END OF THE MODULE 
COMPILE                      *CLM20 INVOKE MASSTOR DATA CHECK TEST
   MODULE CLM30,6000(31,32,46,47,53,104,105,115)LOCK
***       CLM30 - AUTOLOAD CONTROLWARE TO CYBER CHANNEL COUPLER 
**
*    1.0   EXTERNAL MODULE DOCUMENTATION
* 
*    1.1   PURPOSE- 
*          CLM30 AUTOLOADS CONTROLWARE FROM THE SYSTEM SCRATCH FILE 
*          TO THE CYBER CHANNEL COUPLER FROM CYBER HOST.
* 
*    1.2   METHOD-
*          1. DISPLAY AND PRINT THE RUNNING MESSAGE FOR THE MODULE. 
* 
*          2. CALL SUBROUTINE TO READ SCRATCH FILE AND PUT CONTROLWARE
*             NAME IN B5, B6, AND B7. 
* 
*          3. POST CONTROLWARE NAME AND NUMBER OF BLOCKS. 
* 
*          4. SYSREW THE MALET SCRATCH FILE.
* 
*          5. SYSRD A 500B WORD BLOCK OF THE MALET SCRATCH FILE.
* 
*          6. CHECK FOR 77 TABLE AND STRIP OFF IF PRESENT.
* 
*          7. RESERVE THE CHANNEL AND CYBER CHANNEL COUPLER.
* 
*          8. FUNCTION AUTOLOAD CONTROLWARE.
* 
*          9. OUTPUT THE 500B WORDS VIA OUTB CHAINING COMMAND.
* 
*         10. SYSRD 500B WORD BLOCK OF CONTROLWARE FROM THE MALET 
*             SCRATCH FILE. 
* 
*         11. REPEAT STEPS 9 AND 10 UNTIL SYSRD STATUS IS END OF RECORD.
* 
*         12. OUTPUT THE LAST BLOCK OF CONTROLWARE VIA THE OUTB COMMAND.
* 
*         13. CHECK FOR ABNORMAL GENERAL STATUS.
* 
*         14. RELEASE THE CHANNEL AND CYBER CHANNEL COUPLER.
* 
* 
*    1.3   ERRORS REPORTED
*          1. SCRATCH FILE EMPTY OR MISSING 
*          2. CHANNEL PARITY ERROR
*          3. ABNORMAL GENERAL STATUS 
* 
  
*    2.0   INTERNAL MODULE DOCUMENTATION
* 
*    2.1   ENTRY- 
*          CLM30 ASSUMES THAT THE SCRATCH FILE CONTAINS THE CONTROLWARE 
*          TO BE AUTOLOADED.  THE FORMAT OF THE CONTROLWARE BINARY MUST 
*          BE IDENTICAL TO ITS RELEASED FORMAT.  (WITH OR WITHOUT A 
*          LABEL AND DATA IN THE RIGHT-MOST 8 OF A 12-BIT WORD).
* 
*    2.2   EXIT-
*          CLM30 TERMINATES WITH AN END STATEMENT.  REGISTER CONTENTS 
*          ARE NOT USED BY OTHER MODULES. 
* 
*    2.3   SUBMODULES REFERENCED- 
*          NONE.
* 
*    2.4   REGISTERS USED-
*          CLM30 USES REGISTERS B0 TO B10.  REGISTERS ARE USED AS 
*          FOLLOWS--
*            B0 - NUMBER OF 500B BLOCKS OF CONTROLWARE
*            B1 - EXPECTED GENERAL STATUS 
*            B5 - CONTROLWARE NAME
*            B6 - CONTROLWARE NAME
*            B7 - CONTROLWARE REVISION LEVEL
*            B10- STATUS OF THE SYSRD 
* 
*    2.5   BUFFERS USED-
*          CLM30 USES THE INPUT BUFFER FOR CONTROLWARE READ FROM THE
*          SYSTEM SCRATCH FILE.  THE  OUTPUT  BUFFER IS USED FOR
*          AUTOLOADING CONTROLWARE TO THE CYBER CHANNEL COUPLER.
* 
* 
* -----------------DATA DIVISION----------------------------
* 
1  FORMAT AUTOLOAD CONTROLWARE TO CYBER CHANNEL COUPLER 
2  FORMAT CLM30 - CCC AUTOLOADER
3  FORMAT AUTOLOADING *DD BLOCKS OF M*H*H TO CCC
4  FORMAT M*H*H REV *D CONTROLWARE AUTOLOADED TO CCC
5  FORMAT CLM30 READING *DD BLOCKS OF M*H*H REV *D
6  FORMAT CLM30 EC=*OCT SCRATCH FILE EMPTY OR MISSING 
7  FORMAT CLM30 EC=*OCT CHANNEL PARITY ERROR
10 FORMAT CLM30 EC=*OCT ABNORMAL GEN STAT GS=*OCT EXP=*OCT
* 
   EQUATE GENSTAT=12,AUTOLD=0414B 
   EQUATE CSTATUS=0704B 
* 
*------------------INITIALIZATION---------------------------
* 
20 MSG 2 TO PRINT,DISPLAY 
   GOSUB 50                       *READ BLOCKS AND GET TYPE 
   B0 = 0                         *RESET BLOCK COUNTER
   B10 = 0                        *SYSRD STATUS 
   WC = 500 
* 
*------------------AUTOLOAD CONTROLWARE---------------------
* 
24 SYSREW                         *REWIND SCRATCH FILE
   SYSRD, STATUS TO B10 
   IF(IB(0).NE.7700) GOTO 26
   WC = 360B
   COPY IB(120B) TO OB(0) FOR WC  *STRIP OFF 77 TABLE 
   GOTO 27
26 WC = 500B
   COPY IB(0) TO OB(0) FOR WC 
27 RES, ABT 74                    *RESERVE THE CHANNEL AND CCC
   FUNC AUTOLD, ABT 74
* 
30 OUTB CHAIN WC WORDS FROM OB(0), ABT 74   *WRITE DATA 
   SYSRD, STATUS TO B10           *READ BLOCK OF DATA TO PP 
   WC = WT
   COPY IB(0) TO OB(0) FOR WC     *XFER DATA FROM IB TO OB
   IF (WC.EQ.0) GOTO 34           *IF WORD COUNT ZERO 
   B0 = B0+1                      *UPDATE BLOCK COUNT 
   MSG 3 (B0,B5,B6,B7) TO DISPLAY   *DISPLAY BLOCK COUNT
   IF (B10.EQ.0) GOTO 30          *WRITE DATA 
   OUTB WC WORDS FROM OB(0), ABT 74  *WRITE DATA LAST BLOCK 
   MSG 4(B5,B6,B7) TO PRINT,DISPLAY 
   GOTO 40
34 DCN, ABT 74
   MSG 4(B5,B6,B7) TO PRINT,DISPLAY 
* 
*--------------------CHECK AUTOLOAD STATUS------------------------- 
* 
40 RES, ABT 74                    *RES CHANNEL AND CCC
   FUNC GENSTAT, ABT 74 
   INB 1 WORDS TO IB (0), ABT 74      *READ STATUS WORD 
   B1 = 0 
   IF(DC.EQ.53) B1 = 1000         *EXPECTED STATUS FOR 698 TAPE 
   IF(DC.EQ.47) B1 = 1000         *EXPECTED STATUS FOR CARTRIDGE TAPE 
   IF(DC.EQ.46) B1 = 1000         *EXPECTED STATUS FOR CARTRIDGE TAPE 
   IF(IB(0).NE.B1), ERROR 10/06, GOTO 74  *ABNORMAL GENERAL STATUS
   FUNC CSTATUS, ABT 74 
   INB 1 WORDS TO IB (0), ABT 74      *READ STATUS WORD 
   IF(IB(0).AND.2000.NE.0), ERROR 7/02, GOTO 74  *CHANNEL PARITY ERROR
   MSG 4(B5,B6,B7) TO PRINT,DISPLAY 
   MSG 4(B5,B6,B7) TO LINE 2
   GOTO 77                          *EXIT 
* 
*------------------READ CONTROLWARE SUBROUTINE--------------
* 
50 SYSREW                         *REWIND SCRATCH FILE
   SYSRD, STATUS TO B10 
   B0 = B0+1
   IF(B10.NE.2) GOTO 52           *IF NOT EOI ON FIRST READ 
   ERROR 6/7
   MSG 1 TO LINE 2
   MSG EM (EC) TO LINE 3                *EMPTY OR MISSING MESSAGE 
   MSG EM (EC) TO PRINT 
   GOTO 76
52 IF(IB(0).NE.7700) GOTO 54
   WC = 360B
   COPY IB(120B) TO OB(0) FOR WC  *STRIP OFF 77 TABLE 
   GOTO 55
54 WC = 500B
   COPY IB(0) TO OB(0) FOR WC 
55 B5 = OB(30)                    *NAME OF CONTROLWARE
   B6 = OB(31)                    *NAME OF CONTROLWARE
   B7 = OB(33)                    *REV OF CONTROLWARE 
56 SYSRD, STATUS TO B10           *READ BLOCK OF DATA TO PP 
   WC = WT
   IF (WC.EQ.0) GOTO 60           *IF WORD COUNT ZERO 
   B0 = B0+1                      *UPDATE BLOCK COUNT 
   MSG 5 (B0,B5,B6,B7) TO DISPLAY    *DISPLAY BLOCK COUNT 
   IF (B10.EQ.0) GOTO 56          *CONTINUE READING 
60 MSG 5 (B0,B5,B6,B7) TO PRINT,DISPLAY 
   RETURN 
* 
*------------------MODULE ERRORS PROCESSOR------------------
* 
74 MSG 1 TO LINE 1
   MSG 2 TO LINE 2
   MSG EM (EC,IB,B1) TO LINE 4    *DISPLAY ERROR MESSAGE
76 PICTURE
   HALT 
   BLANK
77 END 20 
COMPILE                      CLM30 - LOADS CCC
   MODULE CLM31,6000(31,32,46,47,53,104,105,115),LOCK 
***  CLM31 - CCC MEMORY DUMP ROUTINE
**
*    1.0  EXTERNAL MODULE DOCUMENTATION 
* 
*    1.1  PURPOSE 
* 
*         MODULE CLM31 WILL DUMP THE CCC MEMORY TO THE  PRINT  FILE  IN 
*         40  HEX WORD BLOCKS.  PARAMETER  P7  CONTROLS THE  NUMBER  OF 
*         BLOCKS  AND  PARAMETERS  P8 AND P9 THE STARTING BYTE ADDRESS. 
*         PARAMETER P6 CONTROLS WHETHER THE OUTPUT IS TO THE PRINT FILE 
*         OR THE PPU DISPLAY. 
* 
*    1.2  METHOD
* 
*         1.   INITIALIZE CCC ADDRESS FROM P9 AND  NUMBER OF  BLOCKS
*              FROM P7. TEST P7 PLUS P8 PLUS P9 NOT GREATER THAN MEMORY 
*              SIZE.
*         2.   RES THE I/O CHANNEL. 
*         3.   FUNCTION THE CCC TO LOAD ADDRESS AND LENGTH. 
*         4.   OUTB 2 WORS OF ADDRESS AND LENGTH. 
*         5.   FUNCTION THE CCC TO READ CCC MEMORY. 
*         6.   INB 200 OCTAL WORD TO IB(0). 
*         7    IF P6 IS EQUAL TO ZERO DO STEPS 8 AND 9. 
*         8.   POST MESSAGE TO PRINT OF THE HEX WORD ADDRESS. 
*         9.   POST MESSAGES TO PRINT OF 40 HEX WORD DATA OF CCC
*              MEMORY.
*         10.  IF P6 IS NOT EQUAL TO ZERO DO STEPS 11 AND 12. 
*         11.  POST MESSAGE OF THE HEX WORD ADDRESS TO LINE 1 OF THE
*              PPU DISPLAY. 
*         12.  POST MESSAGE OF 40 HEX WORD DATA OF CCC MEMORY TO LINES
*              2 THROUGH 17D OF THE PPU DISPLAY.
*         13.  IF P6 IS EQUAL TO TEN PAUSE. 
*         14.  IF  P7  IS  NOT EQUAL TO ZERO REPEAT STEPS 2-14 UNTIL P7 
*              OR 2000B BLOCKS ARE PRINTED. 
*         15.  PAUSE THE MODULE.
*         16.  IF GO IS GIVEN EXIT THE MODULE.
* 
*    1.3  ERRORS REPORTED 
* 
*         CLM31 ABORT ON .FUNC LOADADD. COMMAND 
*         CLM31 ABORT ON .FUNC READ. COMMAND
*         CLM31 ABORT ON .OUTB.  COMMAND
*         CLM31 ABORT ON .INB CHAIN.  COMMAND 
*         CLM31 ABORT ON .RES.  COMMAND 
* 
  
*    2.0  INTERNAL MODULE DOCUMENTATION 
* 
*    2.1  ENTRY CONDITIONS
* 
*         PARAMETER WORD P7 IS THE NUMBER OF 40  HEX  WORD  BLOCKS  TO
*         READ  WITH  THE  MAXIMUM  BEING 2000B AND  PARAMETERS P8 AND
*         P9 THE STARTING HEX WORD ADDRESS FOR THE READ.
* 
*    2.2  REGISTER AND BUFFER USAGE 
* 
*         B0   = NUMBER OF BLOCKS TO DUMP (FROM P7) 
*         B1   = LOAD ADDRESS FUNCTION PLUS ADDRESS 
*         B3   = FLAG FOR FIRST/SECOND HALF DATA
*         B4   = LWA OF THE BUFFER (INCREMENTING) 
*         B5   = ADDRESS OF IB OR OB TO SAVE DATA (INCREMENTING)
*         B6   = ADDRESS OF IB WHERE CCC MEMORY (8 BIT DATA IS
*                CONTAINED. (INCREMENTING)) 
*         B7   = PACKED DATA TO BE MOVED
*         B8   = INTERNAL INDEX TO ADDRESSES
*         B9   = IB OR OB LOCATION OF DATA FOR PRINT (INCREMENTING) 
*         B10  = LWA + 1 OF THE BUFFERS 
*         B11  = BLOCK COUNTER
*         B12  = C0MMAND INDEX FOR COMMAND ABORTS 
*         B13  = MODULE ERROR COUNTER 
*         B14  = LOAD ADDRESS FUNCTION PLUS ADDRESS 
*         B15  = MODULE NUMBER
* 
*         OB   = OUTPUT DATA BUFFER (400-401) ADDRESS AND LENGTH
*         IB   = INPUT DATA BUFFER (0-377) DATA FROM CCC
* 
*    2.3  SUBMODULES USED 
* 
*         - NONE
* 
* 
* -----------------DATA DIVISION----------------------------
* 
 0 FORMAT CLM31-CCC MEMORY DUMP ROUTINE 
 1 FORMAT CLM31 ABORT ON .FUNC LOADADD. COMMAND 
 2 FORMAT CLM31 ABORT ON .RES. COMMAND
 3 FORMAT CLM31 ABORT ON .INB. COMMAND
 4 FORMAT CLM31 ABORT ON .FUNC READ. COMMAND
 5 FORMAT CLM31 ABORT ON .OUTB. COMMAND 
 7 FORMAT 
10 FORMAT    *H*H  *H*H  *H*H  *H*H 
11 FORMAT    ----  ----  ----  ---- 
* 
   EQUATE LADDC = 1, FLADD = 500B, RESC = 2, INBC = 3 
   EQUATE READC = 4, FREAD = 701B, OUTBC = 4
* 
* -----------------INITIALIZATION---------------------------
* 
30 B15 = 31D                 *MODULE NUMBER 
   MSG 0 TO DISPLAY,PRINT    *POST MODULE TITLE 
32 B11 = 0                   *INITIALIZE INTERNAL COUNTER 
   B6 = 0                    *SET IB FWA FOR READ 
   B8 = 410                  *RESET INDEX 
   B9 = 0                    *SET BUFFER INDEX
   B10 = 200B                *SET LWA + 1 
   B0 = P7                   *SET NUMBER OF BLOCKS
   B3 = P8.AND.17B.LS.6      *CHECK ADDRESS 
   B4 = P9.RS.6              *CHECK ADDRESS 
   B4 = B3+B4                *CHECK ADDRESS 
   IF (B0+B4.GT.2000) B0 = 2000B-B4  *MAXIMUM BLOCKS TO DUMP
   OB(407) = P8.AND.17.LS.4  *SET STARTING CCC ADDRESS FOR DISPLAY
   OB(410) = P9.RS.8         *SET STARTING CCC ADDRESS FOR DISPLAY
   OB(407) = OB(407) + OB(410)  *SET STARTING CCC ADDRESS FOR DISPLAY 
   OB(410) = P9.AND.377      *SET STARTING CCC ADDRESS FOR DISPLAY
34 B8 = B8 - 1               *SET ADDRESS TO FIRST PART OF DISPLAY MSG
   OB(B8+2) = OB(B8)         *SET NEXT ADDRESS TO FIRST PART
   B8 = B8 + 1               *INCREMENT THE ADDRESS TO SECOND PART
   OB(B8+2) = OB(B8) + 1     *SET ADDRESS TO SECOND PART
   IF (OB(B8+2).GE.400) GOSUB 57
   GOTO 34 WHILE (B8+2.LE.416)  *UPDATE ALL ADDRESSES 
36 B1 = OB(407).RS.4         *SET STARTING CCC ADDRESS
   OB(400) = OB(407).AND.17.LS.8  *SET STARTING CCC ADDRESS 
   OB(400) = OB(400) + OB(410)  *SET STARTING CCC ADDRESS 
   OB(401) = 400B            *SET LENGTH
* 
* -----------------READ DATA FROM CCC-------------------
* 
   B1 = B1 + FLADD           *SET FUNCTION AND STARTING ADDRESS 
   B12 = RESC                *RES COMMAND INDEX 
   RES, ABT 70               *RESERVE I/O CHANNEL 
   B3 = 0                    *CLEAR FIRST/SECOND HALF FLAG
   B12 = LADDC               *LOAD ADD COMMAND INDEX
   FUNC B1, ABT 70           *LOAD ADD MEMORY FUNCTION
   B12 = OUTBC               *OUTB COMMAND INDEX
   OUTB 2 WORDS FROM OB(400), ABT 70  *OUTPUT PARAMETERS TO CCC 
   B12 = READC               *READ FUNC COMMAND INDEX 
   FUNC FREAD, ABT 70        *READ MEMORY FUNCTION
* 
   B12 = INBC                *INB COMMAND INDEX 
42 INB 200 WORDS TO IB(0), ABT 70  *INPUT DATA FROM CCC 
   IF (P6.EQ.0) GOTO 50      *PRINT DATA
* 
* -----------------DISPLAY DATA-----------------------------
* 
   B2 = 0 
*IF -DEF,CMSE17X,2
44 MSG 7 TO LINE B2          *INSERT BLANK LINES BETWEEN BLOCKS 
   B2 = B2 + 1               *INCREMENT LINE NUMBER 
   MSG 10 8 WORDS FROM OB(407) TO LINE B2  *HEX ADDRESS MESSAGE 
   B2 = B2 + 1               *INCREMENT LINE NUMBER 
   MSG 11 TO LINE B2         *HEX ADDRESS MESSAGE 
   B2 = B2 + 1               *INCREMENT LINE NUMBER 
46 MSG 10 8 WORDS FROM IB (B9) TO LINE B2  *PRINT 64 DECIMAL WORDS
   B2 = B2 + 1               *INCREMENT LINE NUMBER 
   IF (P6.NE.0) GOTO 53      *DO NOT PRINT DATA 
* 
* -----------------PRINT DATA-------------------------------
* 
50 MSG 7 TO PRINT            *INSERT BLANK LINES BETWEEN BLOCKS 
   MSG 10 8 WORDS FROM OB(407) TO PRINT  *HEX ADDRESS MESSAGE 
   MSG 11 TO PRINT           *HEX ADDRESS MESSAGE 
52 MSG 10 8 WORDS FROM IB (B9) TO PRINT  *PRINT 64 DECIMAL WORDS
* 
53 B8 = 410                  *RESET INDEX 
54 OB(B8) = OB(B8) + 4       *INCREMENT THE ADDRESS FOR MESSAGE 
   IF (OB(B8).GT.377B) GOSUB 57 
56 GOTO 54 WHILE (B8+2.LE.416)  *UPDATE ALL ADDRESSES 
   B9 = B9 + 10              *INCREMENT THE BUFFER ADDRESS FOR MESSAGE
   IF (B9.GE.B10) GOTO 60    *IF DONE WITH THIS BLOCK 
   IF (P6.EQ.0) GOTO 52      *PRINT DATA
   GOTO 46                   *DISPLAY DATA
* 
57 B8 = B8 - 1
   OB(B8) = OB(B8) + 1
   B8 = B8 + 1
   OB(B8)=OB(B8).AND.7
   RETURN 
* 
60 IF (P6.NE.0) PICTURE      *PAUSE AFTER EACH BLOCK DURING DISPLAY 
   IF (P6.EQ.10) PAUSE       *PAUSE AFTER EACH BLOCK DURING DISPLAY 
   B9 = 0                    *RESET BUFFER INDEX
   B8 = 410                  *RESET INDEX 
   IF (B0.EQ.0) GOTO 64      *DO ONLY 1 BLOCK 
61 GOTO 36 WHILE (B11+1.LT.B0)  *DO ALL BLOCKS
   GOTO 64
* 
* -----------------PAUSE/EXIT-------------------------------
* 
64 PAUSE                     *PAUSE SO LAST LINE IS NOT PRINTED TWICE 
   GOTO 76                   *END MODULE ON A GO
* 
* -----------------ABORT PROCESSOR--------------------------
* 
70 B13 = B13 + 1             *INCREMENT ERROR COUNT 
   MSG 0 TO LINE 0           *MODULE TITLE TO ERROR DISPLAY 
   MSG B12 TO LINE 1         *COMMAND THAT ABORTED
   MSG EM TO LINE 2          *PRODUCT OVERLAY ERROR 
   PICTURE
   HALT 
   BLANK
* 
76 END 30 
COMPILE                           *CLM31 CCC MEMORY DUMP ROUTINE
   MODULE CLM99,6000,(31,32,46,47,53,104,105,115)LOCK 
***  CLM99 - TABLE OF CONTENTS AND PARAMETERS 
**
* 
/ -----------------PARAMETER DESCRIPTION--------------------
/ 
/ 
/         EXECUTIVE SWITCHES
/ 
/                            XXX1 - STOP ON ERROR 
/                            XXX2 - REPEAT MODULE 
/                            XXX4 - REPEAT CONDITION
/                            XX1X - SCOPE LOOP
/                            XX2X - DROP FLAG 
/                            XX4X - CHECKPOINT FLAG 
/                            X1XX - PRINT LOG 
/                            X2XX - DAYFILE LOG 
/                            X4XX - K/L DISPLAY ASSIGNED
/                            1XXX - STANDBY PP OPTION FLAG
/                            2XXX - REPEAT TEST 
/                            4XXX - TERMINAL MODE 
/ 
/         DIAGNOSTIC SWITCHES 
/ 
/                            XXX1 - STOP ON ERROR 
/                            XXX2 - REPEAT MODULE 
/                            XXX4 - REPEAT CONDITION
/                            XX1X - STOP AT BEG OF CONDITION
/                            XX2X - STOP AT BEGINNING OF MOD
/                            XX4X - STOP AT BEG OF TEST 
/                            X1XX - STOP END OF TEST
/                            X2XX - STOP END OF CONDITION 
/                            X4XX - END OF MODULE 
/                            1XXX - PROGRAMABLE SWITCH(R10) 
/                            2XXX - REPEAT TEST 
/                            4XXX - PROGRAMMABLE SWITCH(R11)
/ 
/         P0 - NOT USED BY CLM, BUT PASSED TO CCC TEST
/ 
/         P1 - MEMORY SIZE
/ 
/                            LEGAL PARAMETERS ARE-
/         0000 THROUGH 0007 (DEFAULT = 0, 16K)
/ 
/         P2 - NOT USED BY CLM, BUT PASSED TO CCC TEST
/         P3 - NOT USED BY CLM, BUT PASSED TO CCC TEST
/         P4 - DISABLES 
/ 
/                            XXX1 - DISA ERR MESSAGE POSTING
/ 
/         P5 - FIRST MODULE TO BE RUN IN THE SERIES 
/ 
/                            0000=MODULE 0 (DEFAULT)
/                            0001=MODULE 1
/                            0002=MODULE 2
/                            0003=MODULE 3
/                            0004=MODULE 4
/                            0005=MODULE 5
/                            0006=MODULE 6
/                            0007=MODULE 7
/                            ETC
/ 
/         P6 - TOTAL NUMBER OF MODULES TO BE RUN
/ 
/                            0000= ALL MODULES (DEFAULT)
/ 
/         P7 - NOT USED BY CLM, BUT PASSED TO CCC TEST
/         P8 - NOT USED BY CLM, BUT PASSED TO CCC TEST
/         P9 - NOT USED BY CLM, BUT PASSED TO CCC TEST
/ 
/------------------------MODULE DESCRIPTION-------------------------- 
/ 
/       MODULE        DESCRIPTION               ACCESS LEVEL
/       ------        -----------               ------------
/       CLM00         PARAMETER CHECKER              10 
/       CLM01         CCC TEST LOADER                10 
/       CLM02         CCC TEST MONITOR               10 
/       CLM20         INVOKE DATA TEST(MASSTOR)      10 
/       CLM30         AUTOLOAD CONTROLWARE TO CCC    10 
/       CLM31         CCC MEMORY DUMP                10 
2  END 2
COMPILE,SOURCE               CLM99 - PARAMETER DOCUMENTATION
   MODULE CLM99A,6000,(31,32,46,47,53,104,105,115)LOCK
1  FORMAT COPYRIGHT CONTROL DATA CORP. 1979 
2  PAUSE
   EXIT 
*                         *THE NEXT CARD IS A CALL CDNDM CARD.
*CALL CDNDM 
   END 2
COMPILE,SOURCE
   MODULE CLM99B,6000,(31,32,46,47,53,104,105,115)LOCK
1  FORMAT COPYRIGHT CONTROL DATA CORP. 1979 
2  PAUSE
   EXIT 
*                         *THE NEXT CARD IS A CALL CDNDP CARD.
*CALL CDNDP 
   END 2
COMPILE,SOURCE
