*COMDECK MALCMP 
 COMPILER TITLE  COMPILE - MALET COMPILER AND SUBROUTINES 
**        THE FOLLOWING DOCUMENTS THE FORMAT OF THE MODULE BUFFER 
*         USED BY MALET.
* 
*         ----------------------------------
*         I                                I
*         I          HEADER BLOCK          I   7 CM WORDS FIXED 
*         I--------------------------------I
*         I                                I
*         I      FORMAT STATEMENTS BLOCK   I   0 TO 168 CM WORDS
*         I--------------------------------I
*         I                                I
*         I       COMPILED DATA BLOCK      I   0 TO 129 CM WORDS
*         I--------------------------------I
*         I                                I
*         I        BINARY CODE BLOCK       I   MAX OF 214 CM WORDS
*         I--------------------------------I
*         I                                I
*         I SOURCE CODE BLOCK ( OPTIONAL ) I   MAX OF 720 CM WORDS
*         ----------------------------------
* 
* 
*         THE FORMAT OF THE HEADER BLOCK IS AS FOLLOWS; 
* 
*         ----------------------------------------------------------
*         I                                 I          I           I
*     0   I        MODULE  NAME             I RESERVED I  DEVICE   I
*         I                                 I          I   TYPE    I
*         I---------------------------------+----------+-----------I
*         I          I          I           I          I           I
*     1   I  DC 0    I   DC 1   I   DC 2    I   DC 3   I   DC 4    I
*         I          I          I           I          I           I
*         I----------+----------+-----------+----------+-----------I
*         I          I          I           I          I           I
*     2   I  DC 5    I   DC 6   I   DC 7    I   DC 8   I   DC 9    I
*         I          I          I           I          I           I
*         IL---------+----------+-----------+----------+-----------I
*         IO         I  FORMAT  I  SOURCE   I  SOURCE  I           I
*     3   IC         I   BLOCK  I   BLOCK   I   BLOCK  I MODULE    I
*         IK VERSION I  LENGTH  I  LENGTH   I    FWA   I  LENGTH   I
*         I----------+----------+-----------+----------+-----------I
*         I   CODE   I   CODE   I    DATA   I   DATA   I           I
*     4   I  BLOCK   I  BLOCK   I   BLOCK   I  BLOCK   I RESERVED  I
*         I  LENGTH  I   FWA    I  LENGTH   I   FWA    I           I
*         I----------+----------+-----------+---------1+-----------I
*         I  ENTRY   I  ENTRY   I NO I/O IN I         6I CHECKSUM  I
*         I   LINE   I   PPU    I   MODULE  IRESERVED BI    OF     I
*         I NUMBER   I ADDRESS  I    FLAG   I         II  MODULE   I
*         I----------+----------+-----------+---------T+-----------I
*         I                                                        I
*     6   I                    RESERVED                            I
*         I                                                        I
*         ----------------------------------------------------------
* 
          EJECT 
**        THE LINES BUFFER IS 120 CM WORDS IN LENGTH AND  CONTAINS  ONE 
*         WORD  FOR  EACH  POSSIBLE  LINE  OF  SOURCE CODE INPUT TO THE 
*         COMPILER. ( WORD POSITIONS ARE DIRECTLY  ASSOCIATED  TO  LINE 
*         NUMBERS ) 
* 
*         THE  LINES  BUFFER  IS  UPDATED  WHEN A GOTO STATEMENT NUMBER 
*         APPEARS  WITHIN  A  STATEMENT.  AFTER THE TOTAL SOURCE BUFFER 
*         HAS BEEN COMPILED, THIS BUFFER IS USED  TO  DETERMINE  IF  AN 
*         ERROR  OCCURRED  ON ANY LINES, AND IF SO, WHAT ERROR MESSAGES 
*         TO POST. IT IS ALSO USED BY CLIST TO DETERMINE HOW MANY BYTES 
*         OF  BINARY  CODE  SHOULD  BE  PRINTED  WITH EACH SOURCE LINE. 
* 
*         THIS BUFFER IS ALSO USED IN CONJUNCTION WITH THE  CSN  BUFFER 
*         TO  DETERMINE  IF  ANY  UNDEFINED STATEMENT NUMBERS HAVE BEEN 
*         REFERENCED  WITHIN THE MODULE.  BOTH BUFFERS ARE ALSO USED TO 
*         PLUG IN LINE  NUMBER/PPU  ADDRESS  DATA  FOR  GOTO  STATEMENT 
*         BINARY CODE WITHIN THE MODULE BUFFER. 
* 
* 
* 
*         59           53      41      29         17              0 
*         ----------------------------------------------------------
*         I           I       I       I          I                 I
*         I STATEMENT I  GOTO I   IF  I BYTES IN I  ERROR MESSAGE  I
*         I  NUMBER   I  ADDR I  ADDR I  MODULE  I     ADDRESS     I
*         I           I       I       I          I                 I
*         ----------------------------------------------------------
* 
* 
* 
*         BITS  0 - 17  = IF NON-ZERO, AN ERROR HAS OCCURED ON THIS 
*                         LINE AND THESE BITS POINT TO AN ERROR MSG 
*                         ADDRESS.
* 
* 
*         BITS 18 - 29  = THE NUMBER OF BYTES IN THE MODULE BUFFER
*                         CREATED FOR THIS LINE OF SOURCE CODE. 
* 
*         BITS 30 - 41  =  ADDRESS POINTER TO A BYTE TO BE MODIFIED 
*                          FOR GOTO STATEMENT PROCESS.  IT IS IN THE
*                          FOLLOWING FORM:  
*                               BBBBAAAAAAAA
*                          WHERE BBBB=THE SHIFT COUNT/4 NEEDED TO MODIFY
*                          A BYTE(12 IS LEFT-MOST) IN WORD AAAAAAAA 
*                          RELATIVE TO THE START OF THE MODULE BUFFER.
* 
*         BITS 42 - 53  =  ADDRESS POINTER TO A BYTE TO BE MODIFIED 
*                          FOR IF STATEMENT PROCESS.  IT IS IN THE SAME 
*                          FORM AS BITS 30-41.
* 
* 
*         BITS 54 - 59  = THE STATEMENT NUMBER REFERENCED IN THIS 
*                         SOURCE LINE WITHIN A GOTO STATEMENT.
* 
  
 PLINES   BSSZ   1
          EJECT 
**
*         THE  CSN  BUFFER IS A 64 WORD BUFFER WHOSE WORDS ARE DIRECTLY 
*         ASSOCIATED WITH LEGAL STATEMENT NUMBERS OF 00 THRU 77 OCTAL.
* 
*         THIS BUFFER IS UPDATED WHEN A STATEMENT NUMBER IS DETECTED IN 
*         COLUMNS 1 AND/OR 2 OF A SOURCE CODE LINE. THIS BUFFER IS USED 
*         TO IDENTIFY THE STARTING POINT WITHIN THE MODULE  BUFFER  FOR 
*         BINARY  CODE  GENERATED  AT  A LINE CONTAINING THIS STATEMENT 
*         NUMBER.  REFER TO THE DESCRIPTION OF THE LINES BUFFER  FOR  A 
*         DESCRIPTION  OF  HOW  THIS  BUFFER IS USED AFTER A MODULE HAS 
*         BEEN COMPLETELY COMPILED. 
* 
* 
* 
*          59                             17     11 10            0 
*         ----------------------------------------------------------
*         I F I                           I        I               I
*         I L I           RESERVED        I LINE   I  ADDRESS      I
*         I A I                           I        I               I
*         I G I                           I        I               I
*         ----------------------------------------------------------
* 
* 
*         BITS  0 - 10  = BYTE ADDRESS WITHIN THE CODE BLOCK OF THE 
*                         MODULE BUFFER AT WHICH BINARY CODE STARTS 
*                         FOR THIS STATEMENT NUMBER.
* 
*         BITS 11 - 17  = LINE NUMBER WHERE THIS STATEMENT NUMBER 
*                         OCCURRED IN COLUMNS 1 AND 2.
* 
*         BITS 18 - 58  = RESERVED
* 
* 
*         BIT  59       = SET IF THIS STATEMENT NUMBER OCCURS ON A
*                         DATA DIVISION STATEMENT.
* 
 CSN      BSSZ   64 
 LCSN     EQU    *-CSN
          EJECT 
**        THE FOLLOWING FLOW CHART IDENTIFIES THE LINKAGE OF THE
*         VARIOUS SUBROUTINES USED WITHIN THE COMPILER. 
* 
*                          -------------------------------------- 
*                         I                                      I
*      I------------------I                COMPILE               I
*      I       I          I                                      I
*      I       I           -------------------------------------- 
*      I       I              I                  I             I
*      I       I              I                  I             I
*      I       I              I                  I             I
*      I       I              I                  I             I
*   -------    I       -------------         --------       --------
*  I CRACK I   I      I  STATEMENT  I       I WRSFILE I    I CLIST  I 
*  I       I   I  I---I SUBROUTINES I       I         I    I        I 
*   -------    I  I    -------------         ---------      --------
*              I  I        I       I                           I
*              I  I        I       I                           I
*              I  I        I       I                           I
*              I  I        I       I                           I
*              I  I        I       I                           I
*            ------   ---------   -------------             ------- 
*           I FIND I I CSTOREB I I     CODE    I           I PRINT I
*           I      I I         I I SUBROUTINES I           I       I
*            ------   ---------   -------------             ------- 
*              I
*              I
*              I
*            ------ 
*           I SCAN I
*           I      I
*            ------ 
* 
          EJECT 
*CALL MALCD2
  
*         GLOBAL DATA ITEMS FOR THE COMPILER. 
  
 DABT     VFD    60/3LABT 
 DAT      VFD    60/2LAT
 DAND     VFD    60/3LAND 
 DBIT     VFD    60/3LBIT 
 DBITS    VFD    60/4LBITS
 DBLANK   VFD    60/5LBLANK 
 DBY      VFD    60/2LBY
 DCHAIN   VFD    60/5LCHAIN 
 DCHAR    VFD    60/4LCHAR
 DCODED   VFD    60/5LCODED 
 DC       VFD    60/1LC 
 DCOMPIL  VFD    60/7LCOMPILE 
 DCON     VFD    60/3LCON 
 DCYCLE   VFD    60/5LCYCLE 
 DDAYFIL  VFD    60/7LDAYFILE 
 DDISPLAY VFD    60/7LDISPLAY 
 DECIMAL  VFD    60/7LDECIMAL 
 DEND     VFD    60/3LEND 
 DERROR   VFD    60/5LERROR 
 DE1      VFD    60/2LE1
 DE6      VFD    60/2LE6
 DE8      VFD    60/2LE8
 DFAST    VFD    60/4LFAST
 DFOR     VFD    60/3LFOR 
 DFROM    VFD    60/4LFROM
 DFWD     VFD    60/3LFWD 
 DGAP     VFD    60/3LGAP 
 DGAPS    VFD    60/4LGAPS
 DGOSUB   VFD    60/5LGOSUB 
 DGOTO    VFD    60/4LGOTO
 DHALF    VFD    60/4LHALF
 DH       VFD    60/1LH 
 DHEX     VFD    60/3LHEX 
 DHOLD    VFD    60/4LHOLD
 DIF VFD  60/2LIF 
 DIMAGE   VFD    60/5LIMAGE 
 DIRG     VFD    60/3LIRG 
 DLEFT    VFD    60/4LLEFT
 DLINE    VFD    60/4LLINE
 DLOCK    VFD    60/4LLOCK
 DLONG    VFD    60/4LLONG
 DMEMORY  VFD    60/6LMEMORY
 DMINUS   VFD    60/1L- 
 DMODULE  VFD    60/6LMODULE
 DMSEC    VFD    60/4LMSEC
 DMSG     VFD    60/3LMSG 
 DOB      VFD    60/2LOB
 DOCTAL   VFD    60/5LOCTAL 
 DOF      VFD    60/2LOF
 DOFF     DATA   3LOFF                                                   MAL011K
 DOFFSET  VFD    60/6LOFFSET
 DON      DATA   2LON                                                    MAL011K
 DPARITY  VFD    60/6LPARITY
 DPE      DATA   2LPE                                                    MAL011K
 DPFC6    VFD    60/4LPFC6
 DPFC8    VFD    60/4LPFC8
 DPLOT    VFD    60/4LPLOT
 DPLUS    VFD    60/1L+ 
 DPORT    VFD    60/4LPORT
 DPRINT   VFD    60/5LPRINT 
 DPULSES  VFD    60/6LPULSES
 DRDRAM   VFD    60/5LRDRAM 
 DREAD    VFD    60/4LREAD
 DRECORD  VFD    60/7LRECORDS 
 DREV     VFD    60/3LREV 
 DRIGHT   VFD    60/5LRIGHT 
 DSECTOR  VFD    60/7LSECTORS 
 DSTART   VFD    60/5LSTART 
 DSTATUS  VFD    60/6LSTATUS
 DSTROBE  VFD    60/7LSTROBES 
 DTHP     VFD    60/3LTHP 
 DTO      VFD    60/2LTO
 DTSSP    VFD    60/3LTSS 
 DTYPEA   VFD    60/5LTYPEA 
 DTYPEB   VFD    60/5LTYPEB 
 DUSEC    VFD    60/4LUSEC
 DWHILE   VFD    60/5LWHILE 
 DWIDTH   VFD    60/5LWIDTH 
 DWORD    VFD    60/4LWORD
 DWORDS   VFD    60/5LWORDS 
 DWRITE   VFD    60/5LWRITE 
 DWRRAM   VFD    60/5LWRRAM 
 D16BIT   VFD    60/5L16BIT 
 D3H      VFD    60/2L3H
  
*         BASIC DRIVER ENTRY POINTS.
  
 PA       EQU    10B         FWA FOR PARAMETERS 
  
 STACK    EQU    0                 RELATIVE STACK LOCATION
 STACKAB  DATA   1100B             ORIGIN OF ON-LINE STACK
          DATA   700B              ORIGIN OF OFF-LINE STACK 
  
 LSTACK   EQU    1200B
 DRIVER   EQU    STACK+LSTACK 
 LDRIVER  EQU    2200B
  
 AND      EQU    DRIVER+1 
 BLANK    EQU    AND+4
 CBF      EQU    BLANK+4
 COPY     EQU    CBF+4
 DELAY    EQU    COPY+4 
 DUP      EQU    DELAY+4
 END      EQU    DUP+3
 ENDSUB   EQU    END+3
 ERROR    EQU    ENDSUB+4 
 EXIT     EQU    ERROR+4
 GOSUB    EQU    EXIT+4 
 HALT     EQU    GOSUB+4
 LOG      EQU    HALT+4 
 LS       EQU    LOG+4
 PMSG     EQU    LS+4 
 OR       EQU    PMSG+4 
 PPICTUR  EQU    OR+4 
 PLOT     EQU    PPICTUR+4
 RANDOM   EQU    PLOT+4 
 RETURN   EQU    RANDOM+3 
 RNI      EQU    RETURN+2 
 RS       EQU    RNI+3
 SYS      EQU    RS+4 
 TESTBI   EQU    SYS+4
 TFZCP    EQU    TESTBI+4                                                MAL011K
* 
 POVL     EQU    DRIVER+LDRIVER+14B 
  
* 
*         COMPILER FLAGS
* 
 ZIF      DATA   0                 NON-ZERO WHEN PROCESSING IF STATEMENT
 ZXFER    DATA   0                 NON-ZERO WHEN PROCESSING UNCONDITIONA
*                                  TRANSFER(GOTO,RETURN,EXIT,ETC.)
 ZPREG    DATA   0                 LAST KNOWN SETTING OF P REGISTER 
 ZPREG1   DATA   0
 F16BIT   DATA   0                NON-ZERO WHEN 16-BIT CHANNEL
          EJECT 
 COMPILER TITLE  COMPILE - MALET COMPILER AND SUBROUTINES 
**        COMPILE - PROCESS THE COMPILE DIRECTIVE 
* 
*         J.E.SIPPER. 76/12/08. 
* 
*         COMPILE - THE COMPILE DIRECTIVE CAUSES THE COMPILER TO
*         EXECUTE.  THE COMPILER PROCESSES ALL LINES IN THE SOURCE
*         CODE BUFFER IN THE FOLLOWING FASHION; 
* 
*           . CRACK IS CALLED TO CONVERT A SOURCE LINE TO A WORD STRING 
* 
*           . FIND IS CALLED TO DETERMINE THE SUBROUTINE THAT CAN 
*             PROCESS THIS WORD STRING ( DETERMINED BY A KEYWORD IN THE 
*             WORD STRING ) 
* 
*           . STATEMENT NUMBERS IN COLUMNS 1 AND/OR 2 ARE PROCESSED.
* 
*           . THE STATEMENT SUBROUTINE IS ENTERED TO COMPILE THE WORD 
*             STRING INTO BINARY PPU CODE AND STORE IT INTO THE MODULE
*             BUFFER. 
* 
*         WHEN  ALL LINES HAVE BEEN COMPILED, THE FOLLOWING ITEMS ARE 
*         ACCOMPLISHED; 
* 
*           . STATEMENT NUMBERS ARE RE-PROCESSED AND THE BINARY CODE IN 
*             THE MODULE BUFFER IS MODIFIED TO INCLUDE LINE-NUMBER
*             ASSOCIATED DATA.
* 
*           . CLIST IS CALLED TO PROCESS DATA TO THE OUTPUT FILE.  IF 
*             THE LIST OPTION IS ACTIVE, SOURCE AND BINARY ARE WRITTEN
*             TO THE OUTPUT FILE.  LINES WITH COMPILER ERRORS ARE ALSO
*             RECORDED ON THE OUTPUT FILE AS WELL AS UNDEFINED OR 
*             MULTIDEFINED STATEMENT NUMBERS. 
* 
*           . IF THE SOURCE OPTION IS SELECTED AND NO COMPILER ERRORS 
*             OCCURRED, THE SOURCE CODE IS ADDED TO THE MODULE BUFFER.
* 
* 
*           . IF THE MODULE COMPILED WITHOUT ERRORS, WRSFILE IS CALLED
*             TO WRITE THE MODULE BUFFER TO THE RANDOM FILE.
* 
*         ENTRY   SOURCE = MODULE SOURCE CODE.
*                 CRKBUF = COMPILE DIRECTIVES.(CRACKED INTO STRINGS)
* 
*         EXIT    MODULE = BINARY OF COMPILED MODULE. 
* 
*         ROUTINES CALLED - 
* 
*           POST     - POST MESSAGE.
*           CSTOREB  - STORE GENERATED CODE.
*           FINDOCT  - FIND OCTAL VALUE.
*           FIND     - CRACK STRING TO FIND KEY.
*           CLIST    - PRINT THE SOURCE AND BINARY IF SELECTED. 
*           WRSFILE  - WRITE THE CONTENTS OF MODULE BUFFER TO RANDOM. 
*                      NAMED INDEX FILE.
*           CRACK    - CRACK A SOURCE LINE INTO A WORD STRING.
* 
*           CMODULE  - COMPILE THE MODULE   STATEMENTS. 
*           CDATA    - COMPILE THE DATA     STATEMENTS. 
*           CEQUATE  - COMPILE THE EQUATE   STATEMENTS. 
*           CFORMAT  - COMPILE THE FORMAT   STATEMENTS. 
*           CSLASH   - COMPILE THE /        STATEMENTS. 
*           CBASE    - COMPILE THE BASE     STATEMENTS. 
*           CBLANK   - COMPILE THE BLANK    STATEMENTS. 
*           CCALL    - COMPILE THE CALL     STATEMENTS. 
*           CCBF     - COMPILE THE COMPARE  STATEMENTS. 
*           CCOPY    - COMPILE THE COPY     STATEMENTS. 
*           CDELAY   - COMPILE THE DELAY    STATEMENTS. 
*           CDUP     - COMPILE THE DUP      STATEMENTS. 
*           CEND     - COMPILE THE END      STATEMENTS. 
*           CENDSUB  - COMPILE THE ENDSUB   STATEMENTS. 
*           CEXIT    - COMPILE THE EXIT     STATEMENTS. 
*           CGOTO    - COMPILE THE GOTO     STATEMENTS. 
*           CHALT    - COMPILE THE HALT     STATEMENTS. 
*           CIF      - COMPILE THE IF       STATEMENTS. 
*           CLOG     - COMPILE THE LOG      STATEMENTS. 
*           CMSG     - COMPILE THE MSG      STATEMENTS. 
*           CPASS    - COMPILE THE PASS     STATEMENTS. 
*           CPAUSE   - COMPILE THE PAUSE    STATEMENTS. 
*           CPICTUR  - COMPILE THE PICTURE  STATEMENTS. 
*           CPLOT    - COMPILE THE PLOT     STATEMENTS. 
*           CRANDOM  - COMPILE THE RANDOM   STATEMENTS. 
*           CRETURN  - COMPILE THE RETURN   STATEMENTS. 
*           CWEQX    - COMPILE THE W=X OP Y STATEMENTS. 
*           CYSEOF   - COMPILE THE SYSEOF   STATEMENTS. 
*           CYSPOS   - COMPILE THE SYSPOS   STATEMENTS. 
*           CYSRD    - COMPILE THE SYSRD    STATEMENTS. 
*           CYSREW   - COMPILE THE SYSREW   STATEMENTS. 
*           CYSWR    - COMPILE THE SYSWR    STATEMENTS. 
* 
* 
*         DATA AREAS USED    SOURCE - SOURCE CODE INPUT TO COMPILE. 
*                            CRKBUF - CRACKED LINE PARAMETERS.
*                            MODULE - MODULE BUFFER FOR BINARY/SOURCE.
* 
*         USES   A - 0, 1, 2, 3, 4, 5, 6, 7.
*                X - 0, 1, 2, 3, 4, 5, 6, 7.
*                B - 2, 3, 4, 5, 6, 7.
* 
*         MESSAGES
* 
  
**        STEP 01- CLEAR PLINE, CLEAR COMPILER FLAGS, SET BASE TO OCTAL,
*                  AND GO TO STEP 5.
* 
 COMPILE  DATA   0           ENTRY/EXIT 
          MX6    0
          SA6    PLINE
          SA6    FCERR       CLEAR COMPILER ERROR FLAG
          SA6    FLINE       CLEAR FIRST CODE LINE FLAG 
          SA6    BASE        SET BASE TO OCTAL
  
**      STEP 05- ZERO  FILL BUFFERS THAT ARE TO BE USED BY COMPILE. 
* 
 COM1     SB2    MODULE 
          SB3    SOURCE 
          SX6    B2+B3
          SA6    CLAST       SET LAST ADDRESS ALLOWED FOR DATA STORAGE
          MX6    0
 COM2     SA6    B2          ZERO FILL THE MODULE BUFFER
          SB2    B2+B1
          NE     B2,B3,COM2  IF NOT COMPLETE
          SB2    LINES
          SB3    B2+LLINES
 COM3     SA6    B2          ZERO FILL THE LINES BUFFER 
          SB2    B2+B1
          NE     B2,B3,COM3  IF NOT COMPLETE
          SB2    CSN
          SB3    LCSN+CSN 
 COM4     SA6    B2          ZERO FILL THE STATEMENTS NUMBER BUFFER 
          SB2    B2+B1
          NE     B2,B3,COM4  IF NOT COMPLETE
          SB2    EQUATE1
          SB3    LEQU1+EQUATE1
 COM5     SA6    B2          ZERO FILL THE EQUATE TABLE 
          SB2    B2+B1
          NE     B2,B3,COM5  IF NOT COMPLETE
          IFEQ   CMSE,0 
          SB2    XRBUF
          SB3    B2+LXRBUF
 COM5A    SA6    B2                ZERO FILL CROSS REFERENCE TABLE
          SB2    B2+B1
          NE     B2,B3,COM5A       IF NOT COMPLETE
          ENDIF 
          SX6    EQUATE1-EQUATE 
          SX7    EQUATE 
          LX6    18 
          BX6    X6+X7
          SA6    PEQUATE     SET EQUATE TABLE CONTROL WORD
          MX6    12 
          LX6    48-12
          SA6    MODULE+5    SET NO I/O IN MODULE FLAG
  
**      STEP 06- SET POINTERS TO BUFFERS THAT ARE USED BY COMPILE THEN
*                STEP 7.
* 
          SX6    SOURCE 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,COM5B    IF NOT 16-BIT
          SX1    32          FIRST BYTE TO STORE
          EQ     COM5C
 COM5B    SX1    48 
 COM5C    SX7    MODULE+1 
          LX1    18 
          BX7    X7+X1
          SA6    PSOURCE     SET POINTER TO SOURCE BUFFER 
          SX6    X6+LSOURCE 
          SA6    MSOURCE     SET LAST SOURCE ADDRESS TO MAXIMUM 
          SA7    PSTORE      SET POINTER TO MODULE HEADER WORD 2
          SX6    LINES
          SA6    PLINES      SET POINTER TO LINES BUFFER
          SX6    FORMAT 
          SA6    PFORMAT     SET POINTER TO FORMAT BLOCK OF MODULE BFR
          IFEQ   CMSE,0 
          SX6    XRBUF
          SA6    PXRBUF            SET POINTER TO XREF BUFFER 
          ENDIF 
          MX6    0
          SA6    ZIF               CLEAR -IF- FLAG
          SA6    ZXFER             CLEAR UNCONDITIONAL TRANSFER FLAG
          SA6    ZPREG             CLEAR P-REGISTER FLAG
          SA6    PDATAL      CLEAR POINTER TO LAST DATA BYTE IN MODULE
          SA6    FCARD       CLEAR FIRST CARD FLAG
          SA6    FEND        CLEAR END CARD FLAG
          IFEQ   CMSE,0,1 
          SA6    XRFLAG            CLEAR LOST REFERENCE FLAG
  
**      STEP 07- CALL CRACK TO CRACK THE FIRST SOURCE STATEMENT. GO TO
*                STEP 29 IF FIRST STATEMENT IS NOT MODULE.
* 
          SB2    SOURCE      FWA FOR CRACK
          SB3    18          FIRST CHARACTER IS COLUMN 4
          SB4    20          EXPECTED NUMBER OF WORDS PLUS 1
          RJ     CRACK
          SA1    CRKBUF      LOAD FIRST ELEMENT 
          SA2    DMODULE
          SB7    MSG12       MESSAGE IN CASE OF ERROR 
          BX3    X1-X2
          NZ     X3,COM26    IF NOT MODULE STATEMENT     ERROR
  
**      STEP 08- CALL THE MODULE PROCESSOR. GO TO STEP 29 IF ERRORS 
*                ON THE MODULE STATEMENT, ELSE STEP 9.
* 
          SX6    A1+B1
          SA6    PCRK        SET POINTER TO CRKBUF
          SA3    X6          READ NEXT ITEM 
          RJ     CMODULE
          SA1    FCERR
          SB7    MSG12       MESSAGE IN CASE OF ERROR 
          NZ     X1,COM26    IF MODULE STATEMENT ERROR
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,COM5D    IF NOT 16-BIT
          SX6    32          FIRST BYTE TO STORE
          EQ     COM5E
 COM5D    SX6    48 
 COM5E    SX1    CODE 
          LX6    18 
          BX6    X6+X1
          SA6    PSTORE      SET MODULE POINTER TO FIRST BYTE OF CODE 
  
**      STEP 09- SET A0 REGISTER TO INDICATE DATA DIVISION  COMPILE  IS 
*                IN  PROGRESS.   THIS REGISTER IS USED FOR THIS PURPOSE 
*                THROUGHOUT THE COMPILER THEN STEP 10.
* 
          SA0    B0 
  
**      STEP 10- IF THIS IS A CODE DIVISION STATEMENT, STORE LENGTH 
*                OF CODE CREATED BY THE LAST STATEMENT INTO THE LINES 
*                BUFFER AND BUMP THE PPU INSTRUCTION STACK ADDRESS IN 
*                PSTORE THEN STEP 11. 
* 
 COM6     SB3    A0          DIVISION 
          SA1    PLINES      POINTER TO LINES BUFFER
          NE     B3,B1,COM7  IF NOT CODE DIVISION 
          SA2    PSTORE 
          MX3    12 
          SA5    X1          LINES WORD 
          LX3    48 
          BX4    X2*X3       BYTES FOR THIS SOURCE LINE 
          AX4    18 
          BX6    X4+X5       MERGE BYTE COUNT 
          MX3    12 
          BX7    X2*X3       TOTAL BYTES SO FAR 
          LX4    30 
          MX3    24 
          IX7    X4+X7       ADD TO TOTAL BYTES 
          BX2    -X3*X2      CLEAR BYTE DATA
          SA6    A5          RESTORE LINES WORD 
          BX7    X7+X2
          SA7    A2          RESTORE PSTORE 
          SA2    ZIF
          ZR     X2,COM7           IF LAST STATEMENT WAS NOT IF 
          SA2    ZPREG
          SA3    ZPREG1 
          IX2    X2-X3
          ZR     X2,COM7           IF NO CHANGE IN P
          BX6    X3                X6=VALUE OF P BEFORE LAST STATEMENT
          SA3    ZXFER
          NZ     X3,COM6C          IF LAST STATEMENT HAD UNCONDITIONAL X
          MX6    0                 FLAG P UNKNOWN 
 COM6C    SA6    A2 
  
**      STEP 11- SET POINTERS FOR NEXT LINE. GO TO STEP 24 IF END OF
*                SOURCE CODE BUFFER.  GO TO STEP 23 IF THIS IS A /
*                COMMENT CARD, ELSE STEP 12.
* 
 COM7     SX6    X1+B1
          SA6    A1          BUMP POINTER TO LINES BUFFER 
          SA1    PSOURCE
          SA2    MSOURCE
          SX6    X1+6        BUMP POINTER TO NEXT SOURCE STATEMENT
          SA6    A1 
          IX1    X6-X2
          PL     X1,COM18    IF END OF SOURCE CODE
          SA1    X6          READ NEXT LINE 
          SX2    77B
          LX1    6
          BX3    X1*X2
          SX2    X3-1R/ 
          SB2    CSLASH      ENTRY ADDRESS FOR / COMMENT PROCESSING 
          ZR     X2,COM17B   IF / COMMENT 
          SA3    BLANKS 
          BX2    X3-X1
          ZR     X2,COM17B   10 BLANKS = COMMENT
  
**      STEP 12- CALL CRACK TO CRACK NEXT SOURCE CODE LINE, AND CALL
*                FIND TO GET THE ENTRY POINT ADDRESS OF THE STATEMENT 
*                PROCESSOR THAT CAN PROCESS THIS STATEMENT.  GO TO
*                STEP 22 IF A FIND IS MADE, ELSE STEP 13. 
* 
          SB2    X6          FWA FOR CRACK
          SB3    18          FIRST CHARACTER TO CRACK IS COLUMN 4 
          SB4    60          MAXIMUM WORD COUNT TO CRACK
          RJ     CRACK
          SX6    CRKBUF 
          SA6    PCRK        SET POINTER TO CRKBUF
          SA1    A0+COMB     X1 = FIND CONTROL WORD 
          RJ     FIND 
          PL     B2,COM15    IF A FIND WAS MADE 
  
**      STEP 13- A FIND WAS NOT MADE. GO TO STEP 16 IF WE ARE 
*                PROCESSING THE CODE DIVISION OF THE MODULE, ELSE 
*                STEP 14. 
* 
          SB2    A0-B1
          ZR     B2,COM8     IF PROCESSING THE CODE DIVISION
  
**      STEP 14- GO TO STEP 17 IF NOT PROCESSING  DATA DIVISION, ELSE 
*                STEP 15. 
* 
          PL     B2,COM9
  
**      STEP 15- CALL FIND TO SEARCH FOR CODE DIVISION STATEMENTS.
*                IF A FIND IS MADE THEN STEP 21, ELSE STEP 16.
* 
          SA1    COMB+1 
          RJ     FIND 
          PL     B2,COM12    IF A CODE DIVISION STATEMENT WAS FOUND.
  
**      STEP 16- SEARCH FOR END STATEMENT THEN STEP 20 IF FOUND, ELSE 
*                STEP 17. 
* 
 COM8     SA1    DEND 
          BX2    X3-X1
          ZR     X2,COM11    IF THE END STATEMENT WAS FOUND 
  
**      STEP 17- SET FCERR TO INDICATE COMPILER ERROR TYPE AND MSG. 
*                THEN STEP 18.
* 
 COM9     SX6    MSG18
          SA6    FCERR       SET ERROR FLAG 
  
**      STEP 18- GO TO STEP 10 IF FCERR FLAG IS NOT SET, ELSE STEP 19.
* 
 COM10    SA1    FCERR
          ZR     X1,COM6
  
**      STEP 19- ADD ERROR STATEMENT NUMBER FROM FCERR TO LINES BFR.
*                CLEAR THE FCERR COMPILER ERROR FLAG FOR THE NEXT LINE
*                AND GO TO STEP 10 TO PROCESS THE NEXT LINE.
* 
          SA2    PLINES 
          SA2    X2 
          BX6    X2+X1       MERGE MSG ADDRESS INTO LINES WORD
          SA6    A2          AND RESTORE IT 
          MX7    0
          SA7    A1          ZERO FCERR 
          EQ     COM6        EXIT CURRENT SEQUENCE
  
**      STEP 20- THE END STATEMENT HAS BEEN FOUND. SET A0  TO  INDICATE 
*                TERMINATION  DIVISION  IN  PROCESS  AND GO TO STEP 22. 
* 
 COM11    SA0    B1+B1       GO PROCESS STATEMENT NUMBER IF PRESENT 
          SB2    CEND 
          EQ     COM15
  
**      STEP 21- A CODE DIVISION STATEMENT HAS BEEN FOUND, SO SET A0 TO 
*                INDICATE CODE DIVISION IS BEING PROCESSED.  THEN SET 
*                THE  FORMAT  BLOCK LENGTH IN HEADER WORD 4, AS WELL AS 
*                THE CODE BLOCK FWA, DATA BLOCK FWA, DATA BLOCK LENGTH, 
*                AND OBFWA WITHIN HEADER WORD 5. MOVE THE DATA BLOCK UP 
*                TO THE END OF  THE  FORMAT  BLOCK  WITHIN  THE  MODULE 
*                BUFFER  AND  RESET  POINTERS  TO  REFLECT  THIS  MOVE. 
*                SET THE FLINE FLAG TO THE CURRENT LINE COUNT TO
*                INDICATE THE START OF BINARY CODE AT THIS SOURCE LINE. 
* 
 COM12    SA0    B1 
          SX6    B2 
          SA6    COMD        SAVE THE ENTRY ADDRESS FOR THIS STATEMENT
          SA1    PFORMAT
          SX6    FORMAT 
          IX6    X1-X6             NUMBER OF WORDS IN FORMAT BLOCK
          ZR     X6,COM13    IF NO WORDS
          SA2    MODULE+3 
          BX7    X6 
          LX7    36 
          BX7    X7+X2
          SA7    A2          STORE FORMAT LENGTH IN MODULE HEADER 
 COM13    SA3    PDATAL      LWA OF DATA ( ZERO IF NONE)
          SA2    MODULE+4 
          SB2    X1          IN CASE OF NO DATA 
          ZR     X3,COM14    IF NO DATA BLOCK 
          SX6    X6+LHEADER 
          BX7    X6 
          LX7    12 
          BX7    X7+X2       ADD DATA BLOCK FWA 
          SA7    A2          RESTORE WORD 4 OF THE HEADER 
  
*         MOVE DATA BLOCK UP AGAINST FORMAT BLOCK.
  
          SB2    X1          WHERE TO STORE THE DATA
          MX6    0
          SB4    DATA 
          SB3    X3+B1
          SB3    B3-B4             CM WORDS OF DATA 
 COM13B   SB4    B0 
 COM13A   SA1    DATA+B4     MOVE DATA UP AGAINST FORMAT
          BX7    X1 
          SA7    B2+B4
          SA6    A1          CLEAR WORDS BEHIND US
          SB4    B4+B1
          NE     B4,B3,COM13A     IF ALL WORDS NOT MOVED
  
          SB2    B2+B4       LAST ADDRESS STORED + 1
 COM14    SA1    PFORMAT
          SA2    MODULE+4 
          SX7    B2          LAST ADDRESS STORED INTO PLUS 1
          IX7    X7-X1       NUMBER OF CM WORDS OF DATA 
          SX6    FORMAT 
          IX6    X1-X6             CM WORDS OF FORMAT 
          IX6    X6+X7       CODE BLOCK FWA ( FORMAT + DATA)
          SX6    X6+LHEADER  ADD LENGTH OF HEADER BLOCK 
          LX7    24 
          LX6    36 
          BX7    X7+X6
          BX7    X7+X2
          SA7    A2          MERGE OLD PLUS DATA LENGTH AND CODE FWA
          AX7    36          CODE BLOCK FWA 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,COM14A   IF NOT 16-BIT
          SX6    32          FIRST BYTE TO STORE
          EQ     COM14B 
 COM14A   SX6    48 
 COM14B   SX7    X7+MODULE
          LX6    18 
          SX1    X7+LCODE    LAST WORD+1 THAT CODE CAN BE STORED
          BX7    X7+X6
          SA7    PSTORE      SET POINTERS FOR CODE STORING
          BX6    X1 
          SA1    F16BIT 
          NZ     X1,COM14C   IF 16BIT 
          IFEQ   CMSE,0 
          SX6    X6-86       ADJUST FOR 12 BIT
          ENDIF 
 COM14C   SA6    CLAST       SAVE LAST WORD+1 THAT CODE CAN BE STORED 
  
*         SET POINTER TO FIRST LINE OF EXECUTABLE CODE. 
  
          SA1    PLINES 
          SX7    X1 
          SA7    FLINE       SET LINE FLAG TO CURRENT LINE POINTER
          SA1    COMD 
          SB2    X1          RESTORE SUBROUTINE ENTRY ADDRESS 
  
**      STEP 22- PROCESS THE STATEMENT NUMBER  IF  ONE  IS  PRESENT IN
*                COLUMNS 1 AND 2 OF THIS SOURCE CODE LINE. IF COL 3 IS
*                NOT BLANK, COL1 AND 2 CONTAIN SOMETHING OTHER THAN AN
*                OCTAL NUMBER, OF IF THE STATEMENT NUMBER IS ALREADY
*                DEFINED, GO TO STEP 30.
* 
 COM15    SA1    PSOURCE
          SA2    BLANK3 
          SA1    X1          FIRST SOURCE LINE
          MX3    18 
          BX3    X3*X1
          BX2    X2-X3
          ZR     X2,COM17    IF COL 1-3 ARE BLANKS
          SX4    77B
          LX3    18 
          BX1    X3*X4
          SB7    MSG13       MESSAGE IN CASE OF ERROR 
          SX1    X1-1R
          NZ     X1,COM27    IF COL 3 IS NOT BLANK
          AX3    6
          BX1    X3*X4       LOOK AT COLUMN 2 
          SX1    X1-1R
          NZ     X1,COM15A   IF COLUMN 2 IS NOT A BLANK 
          BX3    -X4*X3      ZERO COLUMN 2
          EQ     COM15B 
  
 COM15A   BX1    X3 
          AX1    6
          SX1    X1-1R
          NZ     X1,COM15B   IF COLUMN 1 IS NOT A BLANK 
          BX3    X3*X4       ZERO COLUMN 1
          LX3    6           POSITION COLUMN 2 TO COLUMN 1
 COM15B   LX3    48 
          IFEQ   CMSE,0 
          MX2    1
          LX2    18 
          BX3    X2+X3             FLAG REFERENCE NOT FOR GLOBAL MAP
          RJ     CXREF             SAVE STATEMENT NUMBER REFERENCE
          ENDIF 
          RJ     FINDOCT     CONVERT X3 TO OCTAL
          SB7    MSG14       MESSAGE IN CASE OF ERROR 
          NG     X5,COM27    IF NOT OCTAL 
          SX2    X5-100B
          PL     X2,COM27    ERROR IF OUT OF RANGE
          SA2    PSTORE 
          MX3    48 
          SB3    A0          DIVISION 
          LX2    12 
          MX4    1
          BX6    -X3*X2      PPU INSTRUCTION ADDRESS
          SA1    PLINES      POINTER TO CURRENT LINE
          SX3    LINES
          IX1    X1-X3
          LX1    11          MAKE ROOM FOR PPU ADDRESS
          SA3    FCMSE
          SA3    X3+STACKAB        GET ABSOLUTE STACK LOCATION
          IX6    X6+X3
          BX6    X6+X1       MERGE LINE NUMBER AND PPU ADDRESS
          NE     B3,B0,COM16 IF NOT DATA DIVISION 
          BX6    X6+X4       SET FLAG BIT 
 COM16    SA1    X5+CSN      READ STATEMENT NUMBER BUFFER WORD
          SB7    MSG15       MESSAGE IN CASE OF ERROR 
          NZ     X1,COM27    IF ALREADY DEFINED 
          SA6    A1          STORE WORD IN CSN BUFFER 
          AX6    11 
          MX1    -7 
          BX6    -X1*X6            CURRENT LINE NUMBER
          SA1    ZIF
          NZ     X1,COM16A         IF -IF- PROCESSED LAST 
          SA1    ZXFER
          NZ     X1,COM16B         IF LAST WAS UNCOND. TRANSFER 
 COM16A   MX6    0
 COM16B   SA6    ZPREG             SET P REGISTER FLAG
  
**      STEP 23- ENTER THE SUBROUTINE THAT CAN PROCESS THIS SOURCE CODE 
*                STATEMENT. ALL SUBROUTINES RETURN TO STEP 18 TO
*                CONTINUE THE COMPILER PROCESSING IF NO ERROR OCCURS. 
*                IF AN ERROR OCCURS, THE SUBROUTINE RETURN TO STEP
*                31 TO SAVE THE ERROR MESSAGE.
* 
 COM17    MX6    0
          SA6    ZIF               CLEAR -IF- FLAG
          SA6    ZXFER             CLEAR TRANSFER FLAG
          SA1    ZPREG
          BX6    X1 
          SA6    ZPREG1            SAVE LAST KNOWN P REGISTER VALUE 
 COM17B   MX0    0                 -IF- PROCESSOR ENTERS HERE TO CONTINU
          SA3    PCRK 
          SA3    X3          NEXT ITEM IN CRKBUF
          SX1    OVAREA            TEMPORARY
          SX2    B2                TEMPORARY
          IX2    X2-X1             TEMPORARY
          PL     X2,COM17A         TEMPORARY
          JP     B2                TEMPORARY
 COM17A   SB7    B2                TEMPORARY
          RJ     CSETP             TEMPORARY
          SB2    B7                TEMPORARY
          SA1    MODULE+5 
          MX6    48 
          LX6    24 
          BX6    X6*X1
          SA6    A1          CLEAR NO I/O IN MODULE FLAG IN HEADER
          JP     B2          ENTER SUBROUTINE 
  
**      STEP 24- THE END  STATEMENT HAS BEEN PROCESED OR ALL THE SOURCE 
*                LINES HAVE BEEN COMPILED. PROCESS THE  LINES  AND  CSN 
*                BUFFERS TO DETERMINE IF WE HAVE ANY UNDEFINED
*                STATEMENT NUMBERS.  IF SO,  SET THE MESSAGE ADDRESS
*                BYTES IN THE LINES BUFFER FOR LATER ERROR REPORTING. 
*                MODIFY PPU CODE WITHIN THE MODULE BUFFER FOR ALL GOTO
*                STATEMENTS BY USING THE LINES AND CSN BUFFERS. 
* 
 COM18    SA1    FLINE
          SX6    LINES
          IX1    X1-X6
          SB5    X1                POINT TO FIRST EXECUTABLE LINE 
          SB6    X6 
          SB7    LLINES 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,COM180   IF NOT 16-BIT
          SA1    PSTORE 
          SX6    X1          SAVE X1
          AX1    18 
          SX1    X1-32
          EQ     COM181 
 COM180   SA1    PSTORE 
          SX6    X1 
          AX1    18 
          SX1    X1-48
 COM181   ZR     X1,COM18A   IF NO DATA STORED IN THE LAST WORD 
          SX6    X6+B1       DATA IS IN THE LAST WORD 
 COM18A   SA6    PSTORE1     SAVE CURRENT MODULE ADDRESS POINTER
          NG     B5,COM21AA        IF NO BINARY DATA TO CHECK 
          MX6    0
          SA6    COME              INITIALIZE STACK ORIGIN
 COM19    SA1    B5+B6
          SX7    7777B
          AX1    18 
          BX6    X1*X7
          SA1    COME              GET CODE LENGTH
          IX6    X6+X1             CALCULATE ORIGIN OF NEXT LINE
          SA6    A1 
          MX7    18 
          SX0    LDC
          SA1    B5+B6
          BX3    X1*X7
          ZR     X3,COM20A         IF NO -GOTO- DATA TO MODIFY
          LX3    6
          SA1    X3+CSN      READ STATEMENT NUMBER WORD 
          LX0    12 
          BX6    X3*X7       POINTER TO MODULE BUFFER 
          BX0    X1+X0       CODE =LDC LINE NUMBER + BYTE ADDRESS 
          ZR     X1,COM19A   IF STATEMENT NUMBER IS UNIDENTIFIED
          PL     X1,COM20    IF STATEMENT NUMBER IN CODE DIVISION 
 COM19A   SX6    MSG5        UNDEFINED STATEMENT NUMBER MESSAGE 
          SA1    B5+B6
          BX6    X6+X1
          SA6    A1          SET ERROR MESSAGE IN LINES BUFFER
          EQ     COM21
  
 COM20    MX7    4
          BX7    X7*X6
          BX6    X6-X7
          LX7    24 
          LX6    12 
          SA1    MODULE+4 
          MX3    48 
          LX1    24 
          BX1    -X3*X1 
          IX6    X6+X1
          SX6    X6+MODULE
          BX6    X6+X7
          SA6    PSTORE      SET POINTER TO MODULE BUFFER 
          RJ     CSTOREB     STORE CODE 
 COM20A   SA1    B5+B6
          MX7    12 
          LX7    42 
          BX3    X1*X7
          ZR     X3,COM21          IF NO -IF- DATA TO MODIFY
          MX7    22 
          BX7    X7*X3             EXTRACT SHIFT COUNT/4
          BX3    X3-X7             EXTRACT RELATIVE ADDRESS 
          AX3    30 
          SX3    X3-1 
          AX7    18 
          BX2    X3 
          SA5    F16BIT      16-BIT FLAG
          ZR     X5,COM20AA  IF NOT 16-BIT
          LX2    1           MULTI BY 3 BYTES PER WORD
          SA5    FLIST       RESTORE CURRENT LIST OPTION
          EQ     COM20AB
 COM20AA  SA5    FLIST       RESTORE CURRENT LIST OPTION
          LX2    2           MULTI BY 5 BYTES PER WORD
 COM20AB  IX2    X2+X3       RELATIVE PPU ADDRESS 
          SA1    MODULE+4 
          MX6    48 
          LX1    24 
          BX1    -X6*X1 
          IX3    X3+X1
          SX3    X3+MODULE         ABSOLUTIZE ADDRESS 
          BX6    X3+X7
          SA6    PSTORE            SET POINTER TO MODULE BUFFER 
          SA1    COME 
          AX7    18                POSITION SHIFT COUNT 
          SB3    X7 
          SA5    F16BIT      16-BIT FLAG
          ZR     X5,COM20BA  IF NOT 16-BIT
          SB2    B3-32
 COM20BB  ZR     B2,COM20C   GET PPU ADDRESS OF JUMP
          SB2    B2+16
          SX2    X2+B1
          SA5    FLIST       RESTORE CURRENT LIST OPTION
          EQ     COM20BB
 COM20BA  SA5    FLIST       RESTORE CURRENT LIST OPTION
          SB2    B3-48
 COM20B   ZR     B2,COM20C         GET PPU ADDRESS OF JUMP
          SB2    B2+12
          SX2    X2+B1
          EQ     COM20B 
 COM20C   IX3    X1-X2             RELATIVE JUMP DISTANCE 
          MX2    55 
          BX2    X2*X3
          ZR     X2,COM20D         IF JUMP WITHIN RANGE 
          SX6    MSG24             IF-CODE OVERFLOW MESSAGE 
          SA1    B5+B6
          BX6    X6+X1
          SA6    A1                SET ERROR MESSAGE IN LINES BUFFER
          EQ     COM21
 COM20D   BX0    X3                GET JUMP COUNT 
          RJ     CSTOREB           STORE CODE 
 COM21    SB5    B5+B1
          NE     B5,B7,COM19 IF ALL WORDS NOT DONE
  
**      STEP 25- CALL CLIST TO PROCESS SOURCE AND BINARY TO THE  OUTPUT 
*                FILE IF THE LIST FLAG IS SET.
* 
 COM21AA  RJ     CLIST
          IFEQ   CMSE,0                                                  MAL007G
          MX6    0                                                       MAL007G
          SB2    XRBUF                                                   MAL007G
          SB3    B2+LXRBUF                                               MAL007G
 COM21AB  SA6    B2                                                      MAL007G
          SB2    B2+B1                                                   MAL007G
          NE     B2,B3,COM21AB     LOOP TO CLEAR XRBUF                   MAL007G
          ENDIF                                                          MAL007G
                                                                         MAL007G
**      STEP 26- IF  FCERR  (COMPILER ERROR FLAG) IS SET OR IF NO END 
*                CARD IN THE MODULE FORCE THE SOURCE TO BE WRITTEN
*                TO THE RANDOM FILE.
  
          SA1    FERR 
          NZ     X1,COM21A   IF SOURCE BUFFER OVERFLOW
          SA1    FCERR
          NZ     X1,COM21A   IF ERROR FLAG SET
          SA1    FEND 
          NZ     X1,COM21B   IF END CARD
 COM21A   SA1    MODULE 
          SX6    B1 
          LX6    12 
          BX6    X1+X6       SET BIT 12 IN MODULE WORD TO FLAG ERR
          SA6    A1 
          EQ     COM21C 
  
**      STEP 27- IF THE SOURCE OPTION FLAG IS SET, MOVE THE SOURCE CODE 
*                BUFFER TO THE MODULE  BUFFER  IMMEDIATELY  BEHIND  THE 
*                CODE  DIVISION DATA. THIS CAUSES THE SOURCE CODE TO BE 
*                CARRIED WITH THE MODULE TO THE RANDOM FILE.
* 
 COM21B   SB3    MODULE      SET B3 AND B4 IN CASE NO SOURCE OPTION 
          SB4    B0 
          SA1    FSOURCE
          ZR     X1,COM23    IF THE SOURCE FLAG IS NOT SET
 COM21C   SA1    PSTORE1
          SB2    SOURCE      FWA OF SOURCE CODE 
          SA3    MSOURCE     LWA+1 OF SOURCE CODE 
          SB3    X1+B1       FWA TO STORE SOURCE CODE IN MODULE BUFFER
          SB4    X3 
          SB4    B4-B2       NUMBER OF WORDS TO STORE 
          SB5    B0          WORDS STORED 
 COM22    SA1    B2+B5       READ DATA FROM SOURCE BUFFER 
          BX6    X1 
          SA6    B3+B5       STORE IT IN THE MODULE BUFFER
          SB5    B5+B1
          NE     B5,B4,COM22 IF ALL WORDS NOT MOVED 
 COM23    SA1    MODULE+3 
          SX2    MODULE 
          BX2    -X2
          SX2    X2+B3             SOURCE FWA INDEX 
          SX6    B4          SOURCE BLOCK LENGTH
          LX6    12 
          BX6    X6+X2       ADD SOURCE BLOCK FWA 
          LX6    12 
          BX6    X6+X1
          SA2    PSTORE1
          SX3    MODULE 
          IX2    X2-X3
          SX3    X2+B4       LENGTH OF THE TOTAL MODULE BINARY
          BX6    X6+X3
          SA6    A1          ADD SOURCE CODE PARAMETERS TO HEADER 
          SA1    MODULE+4 
          BX7    X1 
          AX1    36          CODE FWA 
          IX6    X2-X1
          LX6    48 
          BX7    X6+X7
          SA7    A1          STORE OLD DATA PLUS CODE BLOCK LENGTH
  
**      STEP 28- CALL  WRSFILE  TO WRITE THE MODULE TO THE RANDOM FILE, 
*                AND THEN EXIT  THE  COMPILER.
* 
 COM25    RJ     WRSFILE     WRITE THE MODULE BUFFER ON RFILE 
          MX7    0
          SA7    PLINE       RESET LINE NUMBER TO 0 
          SB7    MSG23
          SA1    FERR 
          NZ     X1,COM26    IF SOURCE BUFFER OVERFLOW
          SB7    MSG16
          SA1    FCERR
          NZ     X1,COM26    IF ERROR FLAG SET
          SB7    MSG19
          SA1    FEND 
          ZR     X1,COM26    IF NO END CARD 
          EQ     COMPILE     RETURN TO CALLER 
  
**
*       STEP 29- CALL POST TO  SEND AN  ERROR MESSAGE TO THE OUTPUT 
*                DEVICES, AND THEN EXIT THE COMPILER. 
* 
 COM26    SB2    B7 
          SA2    MODULE 
          MX5    36 
          BX6    X5*X2
          SA6    B7+3        STORE MODULE NAME INTO MSG 
          RJ     MSG         SEND ERROR MSG TO USER 
          RJ     POST        SEND ERROR TO OUTPUT AND B DISPLAY 
          EQ     COMPILE     RETURN TO CALLER 
  
**      STEP 30- SET COMPILER ERROR FLAG AND EXIT AS THOUGH THIS
*                STATEMENT HAD BEEN COMPILED. 
* 
 COM27    SX6    B7 
          SA6    FCERR       SET COMPILER ERROR FLAG
          EQ     COM10
  
**      STEP 31- ERROR RETURN FROM A COMPILER SUBROUTINE HAS OCCURRED.
*                SAVE THE ERROR MESSAGE AND EXIT AS THOUGH THIS STATE-
*                MENT HAS BEEN COMPILED 
* 
 COM30    SX6    MSG1        SYNTAX ERROR MESSAGE 
 COM31    SA6    FCERR       SET COMPILER ERROR FLAG
          EQ     COM10
  
  
**        THE FOLLOWING TABLE COMB MUST BE KEPT IN ORDER. 
*         THE COMC WORD IS MODIFIED DYNAMICALLY BY THE MODULE 
*         SUBROUTINE DEPENDING UPON WHICH I/O LANGUAGE IS BEING USED. 
* 
 KEY9     EQU    0
 COMB     VFD    36/0,6/KEY1,18/0      CONTROL WORD FOR DATA DIVISION 
 COMC     VFD    30/1,6/KEY9/,6/KEY2,18/0  CONTROL WORD FOR CODE DIV. 
          VFD    60/0                  CONTROL WORD FOR TERM DIVISION 
 COMD     DATA   0           BUFFER FOR SUBROUTINE ENTRY POINT
 COME     DATA   0                 BINARY ORIGIN FOR NEXT LINE
  
 FLIST    DATA   0           LIST OPTION FLAG 
 FLINE    DATA   0           FIRST BINARY CODE GENERATING LINE
 FSOURCE  DATA   0           SOURCE OPTION FLAG 
 BLANKS   DATA   10H
 BLANK3   VFD    60/3L
 BASE     DATA   0           BASE TO USE FOR ALL NUMBERS ( 0 = OCTAL, 
*                            1 = DECIMAL, 2 = HEXADECIMAL ) 
          EJECT 
 CMODULE  TITLE  CMODULE - COMPILE THE MODULE STATEMENT.
**        CMODULE - COMPILE THE MODULE STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CMODULE - COMPILE THE MODULE STATEMENT, THE FIRST CARD OF A 
*         MODULE.  THE REQUIRED FORMAT OF THIS STATEMENT IS AS
*         FOLLOWS.. 
* 
*                    MODULE W,X(A,B,C,D,E,F,G,H,I,J)Y,Z 
* 
*             W = NAME OF MODULE.  MUST BE 3 ALPHA CHARACTERS DEFINING
*                 THE TEST SERIES FOLLOWED BY 2 DECIMAL DIGITS THAT 
*                 DEFINE THE MODULE NUMBER WITHIN THE SERIES. THIS MAY
*                 BE FOLLOWED BY A SUBMODULE IDENTIFIER OF ANY CHAR 
*                 EXCEPT A SEPARATOR. 
* 
*             X = DEVICE TYPE.  A KEYWORD THAT DEFINES THE TYPE OF
*                 DEVICE THIS MODULE IS BEING WRITTEN TO SUPPORT. 
* 
*                           LEGAL 12/16-BIT DEVICE LANGUAGES
*                  3000   - LOW LEVEL I/O FOR 3000 SERIES DEVICES.
*                  6000   - LOW LEVEL I/O FOR 6000 SERIES DEVICES.
*                  BC     - LOW LEVEL I/O FOR BUFFER CONT. DEVICES. 
*                  66X    - HIGH LEVEL I/O FOR 66X TAPE SUBSYSTEMS. 
*                  580    - HIGH LEVEL I/O FOR 512/580 PRINTERS.
*                  667X   - HIGH LEVEL I/O FOR 667X MULTIPLEXERS. 
*                  844HT  - HIGH LEVEL I/O FOR 844 HALF TRACKING. 
*                  844FT  - HIGH LEVEL I/O FOR 844 FULL TRACKING. 
*                  841    - HIGH LEVEL I/O FOR 841 DISK.
*                  65X    - HIGH LEVEL I/O FOR 60X/65X TAPE.
*                  67X    - HIGH LEVEL I/O FOR 67X TAPE 
*                  FMDHT  - HIGH LEVEL I/O FOR FMD/885 HALF TRACK MODE. 
*                  FMDFT  - HIGH LEVEL I/O FOR FMD/885 FULL TRACK MODE. 
*                  FMDSS  - HIGH LEVEL I/O FOR FMD/885 FAULT STIMULATOR.
*                  MST    - HIGH LEVEL I/O FOR MSS/MST. 
*                  MSC    - HIGH LEVEL I/O FOR MSS/MSC. 
*                  LCN    - HIGH LEVEL I/O FOR LCN. 
*                  LCN2   - HIGH LEVEL I/O FOR LCN. 
*                  FSD1   - HIGH LEVEL I/O FOR FSD DISK.
*                  FSD2   - HIGH LEVEL I/O FOR FSD/895 DISK.
*                  LSFMD1 - HIGH LEVEL I/O FOR LSFMD/885 FULL TRACK MODE. 
*                  LSFMD2 - HIGH LEVEL I/O FOR LSFMD/885 FULL TRACK MODE. 
*                  DEMA1  - HIGH LEVEL I/O FOR DEMA (HALF-TRACK) DISK.
*                  DEMA2  - HIGH LEVEL I/O FOR DEMA (HALF-TRACK) DISK.
*                  DEMA3  - HIGH LEVEL I/O FOR DEMA ESM PATH. 
*                  DCART  - HIGH LEVEL I/O FOR CARTRIDGE TAPE.
*                  D895   - HIGH LEVEL I/O FOR 895 DISK.
*                  P895D  - HIGH LEVEL I/O FOR 895 DISK CIO/DMA.
*                  DESM   - HIGH LEVEL I/O FOR ESM/STORNET. 
* 
*                           LEGAL 16-BIT DEVICE LANGUAGES 
*                  PFMDW3 - HIGH LEVEL I/O FOR PFMDW (FULL-TRACK) DISK. 
*                  IFSD - HIGH LEVEL I/O FOR IPI (CM-3 FSDII/XMD3) DISK.
*                  DDAS - HIGH LEVEL I/O FOR IPI (DAS SUBSYSTEM) DISK.
* 
* 
*             A-J = DEVICE CODES THIS MODULE IS WRITTEN TO SUPPORT. 
*                 FROM ONE TO TEN DEVICES CAN BE SUPPORTED PER MODULE.
*                 ( SEE CEVAL DESCRIPTION FOR LEGAL CODES)
* 
* 
*             Y = LOCK FLAG.  KEYWORD, LOCK, FLAGS THAT THIS MODULE 
*                 IS LOCKED AND CANNOT BE MODIFIED OR OVERWRITTEN.
* 
*             Z = 16BIT FLAG.  KEYWORD, 16BIT, FLAGS THAT THIS MODULE 
*                 IS FOR A 16-BIT CHANNEL.
* 
* 
*         ENTRY 
* 
*           CRKBUF CONTAINS THE CRACKED STATEMENT WORD STRING.
*           FCARD CONTAINS THE FIRST CARD FLAG. 
* 
* 
*         EXIT
* 
*           . MODULE NAME IS STORED IN MODULE(0) IN BITS 24 - 59. 
*           . CODE FOR DEVICE TYPE IS STORED IN MODULE(0) BITS 0 - 11.
*           . LOCK BIT AND COMPILER VERSION ARE STORED IN MODULE(3) 
*             BITS 48 - 59. 
*           . 16BIT BIT IS STORED IN MODULE(5) BIT 12.
*           . FCERR FLAG SET IF ERRORS OCCURRED ON THIS CARD (SYNTAX
*             ERROR OR NOT THE FIRST CARD OF THE MODULE)
*           . FCARD SET NON-ZERO TO INDICATE THAT THE FIRST CARD HAS
*             BEEN PROCESSED. 
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF - CONTAINS CRACKED STATEMENT. 
*                            HEADER - HEADER TABLE FPR MODULE BUFFER. 
*                            FCARD  - FIRST CARD FLAG 
*                            FCERR  - COMPILER ERROR FLAG.
* 
*         USES   A - 1, 2, 3, 6.
*                X - 0, 1, 2, 3, 4, 6.
*                B - 2, 6, 7. 
* 
*         MESSAGES   NONE.
* 
  
 CMODULE  DATA   0           ENTRY/EXIT 
          ZR     X3,MOD6     IF END OF STATEMENT
          SX6    MSG18       MESSAGE IN CASE OF ERROR 
          SA1    FCARD
          NZ     X1,MOD7     IF THIS IS NOT THE FIRST MODULE CARD 
          MX2    36 
          BX1    -X2*X3 
          NZ     X1,MOD6     IF MODULE NAME IS GT 6 CHARACTERS
          LX3    24 
          SX1    77B
          BX2    X3*X1       FIRST DIGIT OF MODULE NUMBER 
          SX4    X2-1R0 
          NG     X4,MOD6     IF NOT A NUMBER
          SX4    X2-1R9-1 
          PL     X4,MOD6     IF NOT A NUMBER
          LX3    6
          BX2    X3*X1
          SX4    X2-1R0 
          NG     X4,MOD6     IF NOT A NUMBER
          SX4    X2-1R9-1 
          PL     X4,MOD6     IF NOT A NUMBER
          LX3    30 
          BX6    X3 
          SA6    MODULE      STORE MODULE NAME IN HEADER
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          SA3    X6          READ NEXT ITEM 
          ZR     X3,MOD6     IF END OF STATEMENT
          SA1    MODA 
          RJ     FIND        GET DEVICE TYPE
          NG     B2,MOD6     IF NOT FOUND 
          SA1    MODULE 
          SX6    B2 
          BX6    X6+X1
          SA6    A1          STORE DEVICE TYPE IN HEADER
          SX3    X3-1R( 
          NZ     X3,MOD6     IF NEXT ITEM IS NOT (
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          MX0    0           CLEAR DATA WORD
          SB7    B0          CLEAR COUNTER
 MOD1     SA1    MODB 
          RJ     FIND        GET OCTAL DEVICE CODE
          NG     B2,MOD6     IF NOT FOUND 
          ZR     X2,MOD6     IF DEVICE CODE IS ZERO 
          LX0    12          PREPARE TO RECEIVE NEW CODE
          BX0    X0+X2       ADD CODE TO X0 
          SB7    B7+B1       BUMP COUNT OF DEVICE CODES 
          SB6    B7-5 
          NZ     B6,MOD2     IF X0 IS NOT FULL YET
          RJ     CSTOREB     GO EMPTY IT TO THE MODULE HEADER 
 MOD2     SB6    B7-10
          NZ     B6,MOD3     IF TEN CODES NOT DONE YET
          SX3    X3-1R) 
          NZ     X3,MOD6     IF TERMINATOR NOT FOUND
          EQ     MOD4 
  
 MOD3     SX3    X3-1R) 
          NZ     X3,MOD1     IF TERMINATOR NOT FOUND
 MOD4     RJ     CSTOREB     STORE CODES IF ANY GENERATED 
          SA3    A3+B1       NEXT ITEM FROM CRKBUF
          MX0    0           CLEAR LOCK/VERSION WORD
          ZR     X3,MOD5     IF END OF STATEMENT
          SA1    DLOCK
          BX1    X1-X3
          NZ     X1,MOD4A    IF NOT LOCK
          SX0    X0+4000B    SET LOCK BIT 
          SA3    A3+B1       NEXT ITEM FROM CRKBUF
          NZ     X3,MOD4B 
          EQ     MOD5        IF END OF STATEMENT
  
 MOD4A    SA1    D16BIT 
          BX1    X1-X3
          NZ     X1,MOD6     ERROR EXIT IF NOT LOCK OR 16BIT
          SA1    MODULE+5 
          SX6    B1 
          LX6    12          SET 16BIT BIT
          BX6    X1+X6       MERGE 16BIT BIT AND MODULE+5 
          SA6    MODULE+5    STORE 16BIT BIT IN HEADER BLOCK
          SX6    B1 
          SA6    F16BIT      SET 16BIT FLAG 
          SX6    2           BASE CODE HEX = 2
          SA6    BASE        STORE BASE CODE
          SA3    A3+B1       NEXT ITEM FROM CRKBUF
          ZR     X3,MOD5     IF END OF STATEMENT
          SA1    DLOCK
          BX1    X1-X3
          NZ     X1,MOD6     ERROR EXIT IF NOT LOCK 
          SX0    X0+4000B    SET LOCK BIT 
          SA3    A3+B1       NEXT ITEM FROM CRKBUF
          NZ     X3,MOD6     IF NOT END OF STATEMENT
          EQ     MOD5        IF END OF STATEMENT
  
 MOD4B    SA1    D16BIT 
          BX1    X1-X3
          NZ     X1,MOD6     ERROR EXIT IF NOT 16BIT
          SA1    MODULE+5 
          SX6    B1 
          LX6    12 
          BX6    X1+X6       MERGE 16BIT BIT AND MODULE+5 
          SA6    MODULE+5    STORE 16BIT BIT IN HEADER BLOCK
          SX6    B1 
          SA6    F16BIT      SET 16BIT FLAG 
          SX6    2           BASE CODE HEX = 2
          SA6    BASE        STORE BASE = HEX 
          SA3    A3+B1       NEXT ITEM FROM CRKBUF
          NZ     X3,MOD6     IF NOT END OF STATEMENT
 MOD5     SA1    MODULE 
          MX6    -12
          BX6    -X6*X1      GET DEVICE LANGUAGE TYPE 
          SB2    X1-3        LOW CODES 0-3
          NG     B2,MOD53    IF LOW LEVEL LANGUAGE
          SB6    X6 
          SA1    TKEY8       LEGAL 16-BIT LANGUAGE TYPE TABLE 
          SB2    LKEY8       END OF 16-BIT TABLE
 MOD51    SB7    X1 
          EQ     B6,B7,MOD52 IF 16-BIT LEGAL LANGUAGE TYPE
          SA1    A1+B1       BUMP TABLE ADDRESS 
          SB2    B2-B1       DECREMENT TABLE ENTRIES TO DO
          NZ     B2,MOD51    IF MORE TABLE ENTRIES
          SA1    F16BIT      16BIT FLAG 
          ZR     X1,MOD53    IF 12-BIT AND NOT FOUND
          EQ     MOD6        ERROR IF 16-BIT AND NOT FOUND
  
 MOD52    SA1    F16BIT      16BIT FLAG 
          ZR     X1,MOD6     ERROR IF 12-BIT AND FOUND
 MOD53    SA1    MODULE 
          SB2    X1-2 
          PL     B2,MOD5A    IF LOW LEVEL LANGUAGE
          SB2    B0          SET IT LOW FOR CODES 0-2 
 MOD5A    SA1    FCMSE             GET ON/OFF-LINE FLAG 
          LX1    10 
          BX0    X0+X1             ADD TO VERSION FIELD 
          SA2    VERSION           GET VERSION OF COMPILER
          BX0    X0+X2       MERGE LOCK BIT AND VERSION 
          LX0    48 
          BX6    X0 
          SA6    MODULE+3    STORE THEM IN HEADER BLOCK 
  
*         MAKE DYNAMIC CHANGES TO THE COMPILER BASED ON DEVICE INDEX
*         IN B2.
  
          IFEQ   CMSE,0 
          SA1    OVLPT+B2          GET ADDRESS OF OVERLAY LOAD REQUEST
          LX2    X1 
          AX2    18 
          SB2    X2                SET PARAMETER INDEX
          RJ     LOADOVL           LOAD OVERLAY 
          ENDIF 
          IFNE   CMSE,0 
          SB2    B2-25
          PL     B2,MOD5B    IF DEVICE TYPE GREATER THAN 27D
          SB2    B2+25       RESET DT VALUE 
          EQ     MOD5C
  
 MOD5B    SB2    B2+23       SKIP MISSING LANGUAGE COMPILERS
          ENDIF 
 MOD5C    SA1    MODD+B2
          BX6    X1 
          SA6    COMC        SET KEYWORD CONTROL WORDS FOR STATEMENTS 
          SA1    P0OB+B2
          BX6    X1 
          SA6    FINDMAX     SET OB MAXIMUM FOR THIS DEVICE INDEX 
          SA2    P0IB+B2
          BX6    X2 
          SA6    A6+B1       SET IB MAXIMUM FOR THIS DEVICE INDEX 
          SA2    P0SB+B2
          BX6    X2 
          SA6    A6+B1       SET SB MAXIMUM FOR THIS DEVICE INDEX 
          SA2    MODC 
          LX1    6
          BX6    X1+X2       MODIFY CW FOR OCTAL BUFFER LENGTHS 
          SA6    COPZ 
          SA6    CRAY 
          MX3    54 
          BX6    X6*X3       CLEAR REG2 IN THE CONTROL WORD 
          SX3    100B 
          IX6    X6-X3       MODIFY TO BE LARGEST VALUE ALLOWED 
          SA6    CDAA        SET CDATA CONTROL WORD 
          SA1    FCMSE
          SA1    X1+STACKAB 
          BX4    X1                GET STACK RELOCATION 
          MX3    48 
          SA1    P0OBFWA+B2 
          SA2    TBUF1
          IX1    X1+X4             RELOCATE BUFFER ADDRESS
          BX6    X2*X3       MASK OUT OLD BUFFER ADDRESS
          BX6    X6+X1       ADD IN NEW ONE 
          SA6    A2          STORE OB FWA IN BUFFER TABLE 
          SA1    P0IBFWA+B2 
          SA2    A2+B1
          IX1    X1+X4             RELOCATE BUFFER ADDRESS
          BX6    X2*X3       MASK OUT OLD BUFFER ADDRESS
          BX6    X6+X1       ADD IN NEW ONE 
          SA6    A2          STORE IB FWA IN BUFFER TABLE 
          SA1    P0SBFWA+B2 
          SA2    A2+B1
          IX1    X1+X4             RELOCATE BUFFER ADDRESS
          BX6    X2*X3       MASK OUT OLD BUFFER ADDRESS
          BX6    X6+X1       ADD IN NEW ONE 
          SA6    A2          STORE SB FWA IN BUFFER TABLE 
          MX6    5
          SA6    FCARD       SET FIRST CARD FLAG
          EQ     CMODULE     EXIT 
  
 MOD6     SX6    MSG1        SYNTAX ERROR MESSAGE 
 MOD7     SA6    FCERR       SET COMPILER ERROR FLAG
          EQ     CMODULE     EXIT 
  
  
 MODA     VFD    36/0,6/KEY7,18/0      CONTROL WORD FOR DEVICE TYPE 
 MODB     VFD    42/0,12/7777B,6/0     CONTROL WORD FOR DEVICE CODES
 MODC     VFD    57/0,3/REG2           SHELL FOR CONTROL WORD 
  
  
 FCARD    DATA   0           FIRST CARD FLAG
          EJECT 
 CBASE    TITLE  CBASE - PROCESS THE BASE STATEMENT.
**        CBASE - PROCESS THE BASE STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         BASE IS USED TO CHANGE THE DEFAULT BASE TO USED BY THE
*         COMPILER FORMATS ARE;   BASE OCTAL
*                                 BASE DECIMAL
*                                 BASE HEX
* 
*         ENTRY  (X3) = DISPLAY CODE PARAMETER ON BASE STATEMENT. 
* 
*         EXIT   (BASE) = 0  IF OCTAL 
*                (BASE) = 1  IF DECIMAL 
*                (BASE) = 2  IF HEX 
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  DOCTAL.
*                            DECIMAL. 
*                            DHEX.
*                            BASE.
* 
*         USES   A - 1, 2, 3, 7.
*                X - 1, 2, 3, 7.
*                B - NONE.
* 
  
 CBASE    SA1    F16BIT      16-BIT FLAG
          ZR     X1,CBA      IF NOT 16-BIT
          SA1    DOCTAL 
          BX1    X1-X3
          SX7    B0          CODE FOR BASE OCTAL
          ZR     X1,CBA1     IF BASE OCTAL
          SA1    DECIMAL
          SA2    DHEX 
          BX1    X1-X3
          SX7    B1          CODE FOR BASE DECIMAL
          ZR     X1,CBA1     IF BASE DECIMAL
          BX2    X2-X3
          SX7    X7+B1       CODE FOR BASE HEX
          NZ     X2,COM30    ERROR EXIT IF NOT OCTAL, DECIMAL, OR HEX 
          EQ     CBA1        IF BASE HEX
  
 CBA      SA1    DHEX 
          BX1    X1-X3
          SX6    MSG26       BASE HEX ILLEGAL WHEN NOT 16BIT
          ZR     X1,COM31    ERROR EXIT IF BASE HEX 
          SA1    DOCTAL 
          SA2    DECIMAL
          BX1    X3-X1
          SX7    B0          CODE FOR BASE OCTAL
          ZR     X1,CBA1     IF BASE OCTAL
          BX3    X2-X3
          SX7    B1          CODE FOR BASE DECIMAL
          NZ     X3,COM30    ERROR EXIT IF NOT OCTAL OR DECIMAL 
 CBA1     SA3    A3+B1
          NZ     X3,COM30    IF NOT END OF STATEMENT ERROR EXIT 
          SA7    BASE        STORE BASE SELECTION 
          EQ     COM10       EXIT TO COMPILER 
          EJECT 
 CDATA    TITLE  CDATA  - PROCESS THE DATA STATEMENT. 
**        CDATA  - PROCESS THE DATA STATEMENT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CDATA  - PROCESS THE DATA STATEMENT.  DATA (X,Y) A,B,C,C, ,Z
* 
*           X     = FWA OF THE OUTPUT BUFFER THAT IS TO RECEIVE THE 
*                   FIRST WORD. 
*           Y     = TYPE OF DATA BEING SUPPLIED (OCT,H,3H). 
*           A,ETC = DATA ITEMS TO BE SENT TO SEQUENTIAL BYTES OF THE
*                   OUTPUT BUFFER.
* 
*         WHEN 16BIT AND HEX, H AND 3H DATA CONVERSIONS ARE ILLEGAL.
* 
*         CONTINUATION CARDS ARE ALLOWED FOR THIS STATEMENT BUT MUST
*         CONTAIN A COMMA IN COLUMN 3 OF THE CONTINUATION CARD. 
* 
*         ENTRY 
* 
*           CRKBUF CONTINS THE FIRST SOURCE LINE CRACKED INTO WORD
*           STINGS. 
* 
*         EXIT
* 
*           . COMPILED DATA IS STORED INTO THE DATA BLOCK OF THE MODULE 
*             BUFFER
* 
*           . FCERR FLAG IS SET IF THE DATA BLOCK LIMIT OF 500 OCTAL
*             BYTES IS EXCEEDED OR IF A SYNTAX ERROR IS DETECTED IN 
*             THE INPUT STRING. 
* 
*           . PDATAL IS SET TO THE HIGHEST ADDRESS FOUND SO FAR FOR XX. 
* 
*         ROUTINES CALLED -  CRACK  - CRACK STRING OF CHARACTERS. 
*                            SVREG  - SAVE/RESTORE (X,B) REGISTERS. 
*                            FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CSTORED- STORE GENERATED DATA. 
* 
* 
*         DATA AREAS USED -  CRKBUF - CRACKED WORD STRING OF SOURCE.
*                            MODULE - BINARY OF MODULE. 
* 
*         USES   A - 1, 2, 3, 6, 7. 
*                X - 0, 1, 2, 3, 4, 5, 6, 7.
*                B - 2, 3, 4, 5, 6, 7.
* 
  
 CDATA    SX3    X3-1R( 
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT ( 
          SA3    A3+B1
          IFEQ   CMSE,0,1 
          RJ     CXREF
          SA1    DOB
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT OB
          SA3    A3+B1
          MX2    0
          SB6    B0 
          SB7    B0          SET DEFAULT SUBSCRIPT FOR OB TO ZERO 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CDA1     IF NOT 16-BIT
          SX1    X3-1R( 
          NZ     X1,CDAH5    IF NO SUBSCRIPT
          SX6    A3+B1
          SA6    PCRK        BUMP POINTER TO CRKBUF 
          SA1    CDAA 
          RJ     FIND        GET SUBSCRIPT
          SX6    MSG4        MSG IN CASE OF ERROR 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SX3    X3-1R) 
          SX6    MSG2        MSG IN CASE OF ERROR 
          NZ     X3,COM31    ERROR EXIT IF NOT )
          SB7    X2          ACTUAL SUBSCRIPT 
          SB6    B0          CALCULATE WORD AND BYTE
          SA3    A3+B1       GET NEXT ITEM
 CDAH2    SB6    B6+86       QUARTER THE DATA BUFFER
          SB7    B7-258 
          PL     B7,CDAH2    UNTIL QUADRANT IS FOUND
          SB6    B6-86       IF PAST QUADRANT 
          SB7    B7+258 
 CDAH3    SB6    B6+3 
          SB7    B7-9 
          PL     B7,CDAH3    INCREMENT TO WITHIN THREE WORDS
          SB6    B6-3        IF PAST WORD GROUPING
          SB7    B7+9 
 CDAH4    SB6    B6+1        INCREMENT TO THE BUFFER WORD 
          SB7    B7-3 
          PL     B7,CDAH4    UNTIL WORD IS FOUND
          SB6    B6-1        IF PAST WORD 
          SB7    B7+3 
 CDAH5    SX6    48 
 CDAH6    SX6    X6-16
          SB7    B7-B1
          PL     B7,CDAH6    IF SHIFT COUNT OF BYTE NOT FORMED
          EQ     CDA6A
  
 CDA1     SX1    X3-1R( 
          NZ     X1,CDA5     IF THERE IS NO SUBSCRIPT 
          SX6    A3+B1
          SA6    PCRK        BUMP POINTER TO CRKBUF 
          SA1    CDAA 
          RJ     FIND        GET SUBSCRIPT
          SX6    MSG4        MSG IN CASE OF ERROR 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SX3    X3-1R) 
          SX6    MSG2        MSG IN CASE OF ERROR 
          NZ     X3,COM31    ERROR EXIT IF NEXT ITEM IS NOT ) 
          SB7    X2          SET ACTUAL SUBSCRIPT 
          SB6    B0          CALCULATE WORD AND BYTE FROM SUBSCRIPT 
          SA3    A3+B1       GET NEXT ITEM
 CDA2     SB6    B6+20
          SB7    B7-100 
          PL     B7,CDA2
          SB6    B6-20
          SB7    B7+100 
 CDA3     SB6    B6+5 
          SB7    B7-25
          PL     B7,CDA3
          SB6    B6-5 
          SB7    B7+25
 CDA4     SB6    B6+1 
          SB7    B7-5 
          PL     B7,CDA4
          SB6    B6-1 
          SB7    B7+5 
 CDA5     SX6    60 
 CDA6     SX6    X6-12
          SB7    B7-B1
          PL     B7,CDA6     IF SHIFT COUNT TO SELECTED BYTE NOT FORMED 
 CDA6A    SX7    B6+DATA
          LX6    18 
          BX7    X7+X6       FORM SHIFT COUNT/ADDRESS 
          SA7    PSTORED
          BX6    X2 
          SA6    CDAC        SAVE FIRST BYTE ADDRESS
 CDA7     SA2    A3+B1       GET NEXT ITEM
          SX2    X2-1R) 
          NZ     X2,COM30    ERROR EXIT IF LAST ITEM NOT )
          SX6    A2+B1
          SA6    PCRK        SET NEW POINTER TO CRKBUF
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CDA7A    IF NOT 16-BIT
          SX6    MSG25       IN CASE OF ERROR 
          SA1    D3H
          BX1    X1-X3
          ZR     X1,COM31    3H CONVERSION ILLEGAL
          SA1    DH 
          BX1    X1-X3
          ZR     X1,COM31    H CONVERSION ILLEGAL 
          EQ     CDA7B
  
 CDA7A    SA1    D3H
          BX1    X1-X3
          ZR     X1,CDA14    IF 3H DATA 
          SA1    DH 
          BX1    X1-X3
          ZR     X1,CDA15    IF H DATA
 CDA7B    SA1    DCON 
          BX1    X1-X3
          NZ     X1,COM30    ERROR EXIT IF NOT 3H, H, OCT DATA
* 
*         CONVERT DISPLAY CODE CHARACTERS TO OCTAL AND STORE AS 
*         SEQUENTIAL DATA ITEMS.
* 
          SB7    B0          CLEAR BYTE COUNTER 
          MX0    0           CLEAR DATA WORD
          SA3    A2+B1       GET NEXT DATA ITEM 
 CDA8     ZR     X3,CDA9     IF END OF STRING 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CDA8B    IF NOT 16-BIT
 CDA8A    ZR     X3,CDA9     IF END OF STRING 
          SA1    CDAB 
          RJ     FIND        GET OCTAL NUMBER 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          LX0    16 
          BX0    X0+X2       ADD DATA TO STRING 
          SB7    B7+B1       INCREMENTS BYTE DONE 
          SB6    B7-3 
          NZ     B6,CDA8A    IF WORD IS NOT FULL
          RJ     CSTORHD     STORE DATA IN MODULE BUFF
          SB7    B0          CLEAR BYTES COUNTER
          EQ     CDA8A       CONTINUE CONVERSION
  
 CDA8B    SA1    CDAB 
          RJ     FIND        GET OCTAL NUMBER 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          LX0    12 
          BX0    X0+X2       ADD DATA TO THE STRING 
          SB7    B7+B1       BUMP NUMBER OF BYTES DONE
          SB6    B7-5 
          NZ     B6,CDA8     IF X0 IS NOT FULL
          RJ     CSTORED     STORE DATA IN MODULE BUFFER DATA AREA
          SB7    B0          CLEAR COUNTER
          EQ     CDA8        CONTINUE THE CONVERSION
  
*         THE END OF THE STRING HAS BEEN REACHED. DETERMINE IF THERE IS 
*         A CONTINUATION CARD.
  
 CDA9     RJ     CDA13       GET CONTINUATION CARD IF ONE IS PRESENT
          PL     X1,CDA8     IF THERE IS ONE, CONTINUE THE CONVERSION 
  
*         THE END OF THE STRING HAS BEEN REACHED WITH NO CONTINUATION 
*         CARDS REMAINING.  ENSURE THAT ANY DATA IN X0 IS POSITIONED
*         AND STORED. 
  
 CDA10    ZR     B7,CDA12    IF NO WORDS TO STORE 
          SA1    F16BIT      16-BIT FLAG
          SB6    5
          ZR     X1,CDA11    IF NOT 16-BIT
          SB6    3           BYTES TO STORE 
 CDA11A   SB7    B7+B1       INCREMENT BYTE COUNT 
          LX0    16          POSITION BYTE
          NE     B7,B6,CDA11A   IF NOT POSITIONED TO UPPER BYTE 
          EQ     CDA11B      STORE DATA IN MODULE BUFFER
  
          SB6    5
 CDA11    SB7    B7+B1
          LX0    12 
          NE     B7,B6,CDA11 IF NOT PROPERLY POSITION TO UPPER BYTES
 CDA11B   RJ     CSTORED     STORE DATA IN MODULE BUFFER DATA AREA
  
*         DETERMINE IF THE LAST ADDRESS STORED INTO BY THIS DATA
*         STATEMENT IS HIGHER THAN ANY PREVIOUS DATA STATEMENT. 
  
 CDA12    SA1    F16BIT      16-BIT FLAG
          ZR     X1,CDA12B   IF NOT 16-BIT
          SA1    PSTORED     GET CURRENT POINTER
          SA2    PDATAL      GET LAST HIGH
          SX6    X1 
          AX1    18          POSITION SHIFT COUNT 
          SX1    X1-32       UPPER BYTE FOR NEXT STORE
          EQ     CDA12C 
  
 CDA12B   SA1    PSTORED     GET CURRENT POINTER
          SA2    PDATAL      GET LAST HIGH
          SX6    X1 
          AX1    18          POSITION SHIFT COUNT 
          SX1    X1-48
 CDA12C   NZ     X1,CDA12A   IF NOT UPPER BYTE FOR NEXT STORE 
          SX6    X6-1        LAST HIGH IS ONE LESS NO BYTES STORED YET
 CDA12A   IX1    X6-X2
          NG     X1,COM10    IF LAST IS STILL HIGH, EXIT TO COMPILER
          SA6    A2          STORE NEW HIGH 
          EQ     COM10       EXIT TO COMPILER 
  
*         DETERMINE IF THERE IS A CONTINUATION DATA CARD. 
  
 CDA13    DATA   0
          SA1    PSOURCE
          SA2    X1+6        READ NEXT SOURCE LINE
          MX3    -18
          AX2    42 
          BX2    -X3*X2 
          SX2    X2-3R  , 
          MX1    1           SET NO CONTINUATON FLAG
          NZ     X2,CDA13    EXIT IF NO CONTINUATION CARD 
          SX6    A2 
          SA6    A1          BUMP PSOURCE TO NEXT LINE
          SA1    PLINES 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO LINE BEING PROCESSED 
          SB1    B0 
          RJ     SVREG       SAVE X AND B REGISTERS 
          SA2    PSOURCE
          SB2    X2          CRACK FIRST WORD OF SOURCE LINE
          SB3    18          START WITH COLUMN 4
          SB4    60          MAXIMUM WORDS TO CRACK 
          RJ     CRACK       CRACK NEXT SOURCE LINE 
          RJ     SVREG       RESTORE X AND B REGISTERS
          SX6    CRKBUF 
          SA6    PCRK 
          SA3    X6          READ FIRST DATA ITEM 
          MX1    0           INDICATE THERE IS A CONTINUATION CARD
          EQ     CDA13       EXIT 
  
  
*         3H CONVERSION HAS BEEN SELECTED. THIS CONVERSION PACKS THREE
*         HEX CHARACTERS INTO A 12 BIT BYTE.
  
 CDA14    SB4    B1          SET 3HEX PROCESSING FLAG 
          EQ     CDA16       ENTER COMMON SEQUENCE
  
*         HEX CONVERSION HAS BEEN SELECTED.  THIS CONVERSION PACKS TWO
*         HEX CHARACTERS INTO THE LOWER 8 BITS OF A 12 BIT BYTE AND 
*         ZEROS THE UPPER 4 BITS. 
  
 CDA15    SB4    B0          CLEAR 3HEX PROCESSING FLAG 
  
*         CONVERT 4 CHARACTERS OF THE NEXT WORD TO HEX. ERROR EXIT IF 
*         WORD CONTAINS MORE THAN 4 CHARACTERS. 
  
 CDA16    SB5    B0          CLEAR FLAG COUNTER 
          SB7    15          SET CHARACTER COUNTER
          MX0    0           CLEAR DATA BUILDING WORD 
          SA3    A2+B1       GET FIRST DATA ITEM
 CDA17    SB6    4           SET LOOP COUNT 
          MX5    0           CLEAR CONVERTED WORD 
          NZ     X3,CDA18    IF NOT END OF STRING 
          RJ     CDA13       DETERMINE IF THERE IS A CONTINUATION CARD
          NG     X1,CDA26    IF NO CONTINUATION 
          EQ     CDA17       CHECK IF THERE IS DATA ON THIS CARD
  
 CDA18    LX3    6           POSITION NEXT CHARACTER
          MX4    -6 
          BX2    -X4*X3      ISOLATE CHARACTER
          ZR     X2,CDA21    SKIP ZERO CHARACTER
          SX1    X2-1R0 
          NG     X1,CDA19    IF NOT A NUMBER
          SX6    X2-1R9-1 
          SX2    X2-1R0 
          NG     X6,CDA20    IF A LEGAL NUMBER
          EQ     COM30       ERROR EXIT IF NOT A LEGAL NUMBER 
  
 CDA19    SX6    X2-1RF-1 
          PL     X6,COM30    ERROR EXIT IF NOT A THRU F 
          SX2    X2+9 
 CDA20    LX5    4
          BX5    X5+X2       ADD CHARACTER TO THE STRING
 CDA21    SB6    B6-B1       DECREMENT CHARACTERS IN X3 
          NZ     B6,CDA18    IF X3 IS NOT EMPTY 
          AX3    24 
          NZ     X3,COM30    ERROR EXIT IF MORE THAN 4 CHARACTERS 
          LX5    44          POSITION CONVERTED CHAR TO UPPER BITS
          SB6    4           RESET COUNT
 CDA22    NZ     B4,CDA24    IF PROCESSING 3HEX 
          ZR     B5,CDA23    FIRST CHARACTER FLAG -TIME TO INSERT ZEROS 
          SB5    B0          CLEAR FLAG -INDICATE TIME TO INSERT ZEROS
          EQ     CDA24
  
 CDA23    LX0    4           ADD A HEX CHARACTER OF ZEROS 
          SB5    B1          BUMP FLAG
          SB7    B7-B1       DECREMENT NUMBER OF SLOTS LEFT IN X0 
          NZ     B7,CDA24    IF NOT FULL
          RJ     CSTORED     STORE CURRENT DATA 
          SB7    15          RESET CHARACTER COUNT
 CDA24    LX5    4
          MX4    -4 
          BX2    -X4*X5      GET NEXT CHARACTER 
          LX0    4
          BX0    X0+X2       ADD CHARACTER TO THE STRING
          SB7    B7-B1       DECREMENT NUMBER OF SLOTS LEFT IN X0 
          NZ     B7,CDA25    IF NOT FULL
          RJ     CSTORED     SAVE CURRENT DATA
          SB7    15          RESET CHARACTER COUNT
 CDA25    SB6    B6-B1       DECREMENT CHARACTERS LEFT IN X5
          NZ     B6,CDA22    IF NOT EMPTY 
          SA3    A3+B1       GET NEXT WORD
          EQ     CDA17       CONVERT IT TO HEX
  
*         THE END OF THE STRING HAS BEEN REACHED AND NO CONTINUATION
*         CARDS EXIST. ENSURE THAT ANY DATA IN X0 IS POSITIONED AND 
*         STORED. 
  
 CDA26    SB6    B7-15
          ZR     B6,CDA12    IF X0 IS EMPTY PREPARE TO EXIT TO COMPILER 
 CDA27    SB7    B7-B1
          LX0    4
          NZ     B7,CDA27    IF NOT PROPERLY POSITIONED 
          RJ     CSTORED     STORE DATA 
          EQ     CDA12       PREPARE TO  EXIT TO COMPILER 
  
 CDAA     VFD    42/0,12/477B,6/0       CONTROL WORD FOR SUBSCRIPT
 CDAB     VFD    21/0,6/17B,15/0,12/7777B,6/0   CONSTANTS CONTROL WORD
 CDAC     BSSZ   1           BUFFER FOR BYTE ADDRESS
 CDA3H    DATA   0           PROCESSING FLAG
          EJECT 
 CEQUATE  TITLE  CEQUATE - PROCESS THE EQUATE STATEMENT.
**        CEQUATE - PROCESS THE EQUATE STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CEAUATE - ASSIGN A VALUE TO A SYMBOL. 
* 
*         J.E.SIPPER. 76/12/08. 
* 
*         CEQUATE- ASSIGN A VALUE TO A SYMBOL.  A MAXIMUM OF
*         TEN EQUATED VALUES CAN BE USED WITHIN A MODULE.  ONCE 
*         DEFINED IN THE DATA DIVISION, THE EQUATED SYMBOLS CAN BE
*         USED ANYWHERE WITHIN THE CODE DIVISION IN PLACE OF AN 
*         OCTAL VALUE. LEGAL FORMAT OF THIS STATEMENT IS AS FOLLOWS.
* 
*               EQUATE X TO Y 
*               EQUATE X TO Y, X TO Y, .... 
* 
*           X = ANY CHARACTER STRING OF 3 TO 7 CHARACTERS 
*           Y = ANY LEGAL CONSTANT
* 
*         ENTRY 
* 
*           CRKBUF IS THE WORD STRING OF THE STATEMENT
* 
*         EXIT
* 
*           EQUATE TABLE IS UPDATED TO INCLUDE THIS ENTRY.  IF THE
*           SAME EQUATE X STRING IS REUSED, THE LATEST REPLACES THE 
*           PREVIOUS. 
* 
*         ROUTINES CALLED -  FIND - FIND THE NEXT ITEM FROM SOURCE. 
* 
*         DATA AREAS USED -  PCRK - POINTER TO CRACKED BUFFER.
* 
*         USES   A - 1, 2, 3, 4, 6. 
*                X - 0, 1, 2, 3, 4, 6.
*                B - 2, 3.
* 
  
 CEQUATE  ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          IFEQ   CMSE,0,1 
          RJ     CXREF             SAVE EQUATE SYMBOL REFERENCE 
          SA1    PCRK 
          SA2    DTO
          SA4    X1+B1       READ NEXT ITEM FROM CRKBUF 
          SX1    X4-1R= 
          ZR     X1,CEQU0          IF NEXT ITEM IS =
          BX1    X4-X2
          NZ     X1,COM30    ERROR EXIT IF NOT TO 
 CEQU0    SX6    A4+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          BX0    X3          SAVE EQUATED VALUE IN X0 
          SA1    CEQA 
          RJ     FIND        SEARCH FOR OCTAL VALUE 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          MX4    42          MASK FOR 7 CHARACTERS
          BX1    -X4*X0 
          SX6    MSG7        MESSAGE IN CASE OF ERROR 
          NZ     X1,COM31    ERROR EXIT IF NAME IS GT 7 CHARACTERS
          MX4    12 
          BX1    -X4*X0 
          ZR     X1,COM31    ERROR EXIT IF NAME IS LT 3 CHARACTERS
          SB2    EQUATE1
          SB3    EQUATE1+LEQU1
 CEQU1    SA1    B2          NEXT ITEM FROM EQUATE BUFFER 
          ZR     X1,CEQU2    IF EMPTY ENTRY FOUND 
          BX1    X1*X4       MASK NAME
          BX1    X1-X0
          ZR     X1,CEQU3    IF SAME EQUATED NAME 
          SB2    B2+B1
          NE     B2,B3,CEQU1 IF ALL WORDS NOT TESTED
          SX6    MSG6        ERROR MESSAGE FOR TABLE FULL 
          EQ     COM31       ERROR EXIT IF EQUATE TABLE IS FULL 
  
 CEQU2    SA1    PEQUATE
          SX6    EQUATE 
          AX1    18 
          SX1    X1+B1       BUMP LENGTH OF THE EQUATE TABLE
          LX1    18 
          BX6    X6+X1
          SA6    A1          STORE NEW EQUATE TABLE CONTROL WORD
  
 CEQU3    SX6    X2 
          BX6    X6+X0       MERGE NAME AND VALUE 
          SA6    B2          STORE ITEM IN EQUATE TABLE 
          NZ     X3,CEQUATE  IF NOT END OF STATEMENT
  
          EQ     COM10       RETURN TO COMPILER 
  
*         EQUATED VALUES ASSIGNED BY THE COMPILER 
  
 EQUATE   VFD    42/2LSE,18/SW.SE        STOP ON ERROR
          VFD    42/2LRM,18/SW.RM        REPEAT MODULE
          VFD    42/2LRC,18/SW.RC        REPEAT CONDITION 
          VFD    42/2LCM,18/SW.RC+SW.RM  REPEAT CONDITION OR MODULE 
          VFD    42/2LSL,18/SW.SL        SCOPING LOOP (RM+RC AND NOT SE)
          VFD    42/2LTM,18/SW.TM        TERMINAL MODE
          VFD    42/2LKL,18/SW.KL        K/L DISPLAY
          VFD    42/2LPL,18/SW.PL        PRINT LOG
          VFD    42/2LDL,18/SW.DL        DAYFILE LOG
          VFD    42/2LMS,18/SW.RM+SW.SE  RM OR SE 
          VFD    42/2LCS,18/SW.RC+SW.SE  RC OR SE 
          VFD    42/2LPD,18/SW.PL+SW.DL  PL OR DL 
          VFD    42/2LBC,18/SW.BC  BEGINING OF CONDITION
          VFD    42/2LBM,18/SW.BM  BEGINNING OF MODULE
          VFD    42/2LBT,18/SW.BT  BEGINNING OF TEST
          VFD    42/2LTE,18/SW.TE  TEST END STOP
          VFD    42/2LCE,18/SW.CE  CONDITION END
          VFD    42/2LME,18/SW.ME  MODULE END 
          VFD    42/2LS1,18/SW.S1  PROG SWITCH 1
          VFD    42/2LRT,18/SW.RT  REPEAT TEST
          VFD    42/2LS2,18/SW.S2  PROG SWITCH 2
 EQUATE1  BSSZ   20          EQUATED VALUES BUFFER
 LEQUATE  EQU    *-EQUATE    LENGTH OF EQUATE TABLE 
 LEQU1    EQU    *-EQUATE1   LENGTH OF USER EQUATES 
 CEQA     VFD    21/0,6/17B,15/0,12/7777B,6/0 
 PEQUATE  DATA   0
          EJECT 
 CFORMAT  TITLE  CFORMAT - PROCESS FORMAT STATEMENT.
**        CFORMAT - PROCESS FORMAT STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CFORMAT - PROCESS THE FORMAT STATEMENT.  GENERATE A CONTROL 
*         WORD FOR THIS STATEMENT,MOVE IT AND THE SOURCE LINE TO THE
*         FORMAT BLOCK OF THE MODULE BUFFER WHICH CONTAINS THE BINARY 
*         OF THE CURRENT MODULE.
* 
*           XX FORMAT MESSAGE STRING INCLUDING UP TO 8 KEYWORDS 
* 
*           X        = STATEMENT NUMBER OF 00 TO 77 OCTAL 
*           KEYWORDS = *OCT,*H ,*3H, OR *DEC.  THE * FLAGS A POINT
*                      WHERE MICRO SUBSTITUTION OF DATA IS TO OCCUR 
*                      LATER. THE CHARACTERS THAT FOLLOW IT IDENTIFY
*                      THE FORMAT OF THE DATA THAT IS TO BE INSERTED. 
*                      WHEN KEYWORD 16BIT IS PRESENT IN THE MODULE CARD,
*                      *OCTA,  *OCTAL, *HEX, AND *DECI BECOME LEGAL 
*                      KEYWORDS.
* 
*         EXAMPLE;
* 
*            10 FORMAT EXPECTED = *OCT, RECEIVED = *OCT 
* 
*         ENTRY - CRKBUF CONTAINS THE CRACKED STATEMENT.
* 
*         EXIT
* 
*           A 7-WORD ENTRY IS ADDED TO THE FORMAT BLOCK OF THE MODULE 
*           BUFFER AND THE PFWORD POINTER IS ADVANCED TO THE NEXT LINE
*           AREA.  THE FCERR FLAG IS SET TO INDICATE A COMPILER ERROR 
*           IF THE FORMAT BLOCK IS FULL (ONLY 15 FORMAT STATEMENTS ARE
*           ALLOWED PER MODULE).
*           THE ENTRY STORED CONTAINS A CONTROL WORD FOLLOWED BY 50 
*           DISPLAY CODE CHARACTERS.
* 
*           CONTROL WORDS FORMAT
* 
*             BITS 52-59 = STATEMENT NUMBER 
*             BITS 49-51 = WORD NUMBER THAT CONTAINS THE FIRST *
*             BITS 43-48 = SHIFT COUNT WITHIN THE WORD THAT 
*                          CONTAINS THE FIRST * 
*             BITS 39-42 = CONVERSION CODE
*                            1 = 2 CHARACTER OCTAL      *O
*                            2 = 3 CHARACTER OCTAL      *OC 
*                            3 = 4 CHARACTER OCTAL      *OCT
*                            4 = 5 CHARACTER OCTAL      *OCTA 
*                            5 = 6 CHARACTER OCTAL      *OCTAL
*                            6 = 2 CHARACTER HEX        *H
*                            7 = 3 CHARACTER HEX        *HE 
*                            8 = 4 CHARACTER HEX        *HEX
*                            9 = RESERVED 
*                           10 = 2 CHARACTER DECIMAL    *D
*                           11 = 3 CHARACTER DECIMAL    *DE 
*                           12 = 4 CHARACTER DECIMAL    *DEC
*                           13 = 5 CHARACTER DECIMAL    *DECI 
*                           14 = RESERVED 
*                           15 = 2 CHARACTER ALPHA      *A
*             BITS 26-38 = SAME AS BITS 39-51 FOR THE SECOND *
*             BITS 13-25 = SAME AS BITS 39-51 FOR THE THIRD * 
*             BITS 00-12 = SAME AS BITS 39-51 FOR THE FOURTH *
* 
*           A SECOND CONTROL WORD IDENTICAL TO THE ONE ABOVE IS CREATED 
*           FOR THE FIFTH THRU EIGHT * .
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CRACK  - CRACK STRING OF CHARACTERS. 
* 
*         DATA AREAS USED -  CRKBUF - CONTAINS CRACKED WORD STRING. 
*                            MODULE - BINARY OF COMPILE MODULE
*                            PFORMAT- POINTER TO FORMAT BLOCK 
*                            FCERR  - COMPILER ERROR FLAG 
* 
*         USES   A - 1, 3, 5, 6, 7. 
*                X - 1, 2, 3, 4, 5, 6, 7. 
*                B - 2, 3, 4, 5, 6, 7.
* 
  
 CFORMAT  SA1    PSOURCE
          SB3    B0          SET PARAMETERS FOR CRACK - START AT COL 1
          SB4    B1          CRACK ONE WORD 
          SB2    X1          START AT FIRST WORD OF CURRENT LINE
          RJ     CRACK
          SX6    CRKBUF 
          SA6    PCRK        SET POINTER TO CRKBUF
          SA1    CFOA 
          RJ     FIND        GET STATEMENT NUMBER 
          SX6    MSG5 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SA1    PFORMAT
          SX6    MSG22
          SX4    DATA 
          IX4    X1-X4
          PL     X4,COM31    ERROR EXIT IF FORMAT BLOCK OVERFLOW
          LX2    52          POSITION STATEMENT NUMBER
          BX6    X2 
          SA6    X1          STORE STATEMENT NUMBER INTO FORMAT BLOCK 
          SA6    A6+B1
          SA3    A6+B1       A3= TERMINAL ADDRESS +1 FOR SUBSTITUTIONS
          SA1    PSOURCE
          SB2    5           SET TERMINAL COUNT 
          SA1    X1          PREPARE A1 FOR ADDRESS OF DATA 
          SB3    B0          SET CHARACTER SHIFT COUNT
          SB4    B0          CLEAR * PROCESSING IN PROGRESS FLAG
          SB5    A6-B1       SET RESULT WORD POINTER
          SB6    39          SET RESULT BYTE SHIFT COUNT
          MX2    -6          SET CHARACTER MASK 
          MX4    0           CLEAR WORD COUNTER 
          SX0    1R          SET CHARACTER TO SUBSTITUTE
  
*         GET WORD. 
  
 CFO1     SA1    A1+B1       GET NEXT SOURCE WORD 
  
*         GET NEXT CHARACTER. 
  
 CFO2     LX1    6
          BX3    -X2*X1      GET NEXT CHARACTER 
          NZ     B4,CFO5     IF * PROCESSING IS IN PROGRESS 
 CFO2A    SX5    X3-1R* 
          NZ     X5,CFO4     IF THIS CHARACTER IS NOT THE SPECIAL ONE 
          SB4    B1          SET FLAG TO INDICATE * PROCESSING
          SX7    X4 
          LX7    10 
          SX5    B3          CHARACTER SHIFT COUNT
          LX5    4
          BX7    X7+X5       ADD CHARACTER SHIFT COUNT TO CODE
 CFO3     BX1    X2*X1       CLEAR THE CHARACTER
          BX1    X1+X0       SUBSTITUTE NEW CHARACTER 
 CFO4     SB3    B3+6        BUMP SHIFT COUNT 
          SB7    60 
          GT     B3,B7,CFO4A IF DONE WITH FORMAT
          NE     B3,B7,CFO2  IF WORD NOT USED UP
          BX6    X1 
          SA6    A6+B1       STORE WORD IN FORMAT BLOCK 
          SX4    X4+B1       INCREMENT WORDS PROCESSED
          SB3    B0          RESET CHARACTER SHIFT COUNT
          SB7    X4 
          NE     B2,B7,CFO1  IF ALL WORDS NOT DONE
          SB3    60 
          MX3    0
          NZ     B4,CFO7     IF LAST WORD HAD CODE NOT STORED 
 CFO4A    SX6    A6+B1
          SA6    PFORMAT     BUMP POINTER TO FORMAT BLOCK 
          EQ     COM10       EXIT TO COMPILER 
  
*         * PROCESSING IS IN PROGRESS. DETERMINE IF THE FIRST CHARACTER 
*         HAS BEEN FOUND YET. 
  
 CFO5     NE     B1,B4,CFO6  IF NOT THE FIRST CHARACTER 
          SB7    A3-B5
          ZR     B7,COM30    ERROR EXIT IF MORE THAN 8 SUBSTITUTIONS
          SB4    CFOO        SET POINTER TO OCT STRING
          SX5    X3-1RO 
          SX7    X7+B1       SET CODE FOR OCTAL 
          ZR     X5,CFO3     IF FIRST CHARACTER IS O
          SB4    CFOH        SET POINTER TO HEX STRING
          SX5    X3-1RH 
          SX7    X7+5        SET CODE FOR HEX 
          ZR     X5,CFO3     IF FIRST CHARACTER IS H
          SB4    CFOH3       SET POINTER TO 3H STRING                    MAL045K
          SX5    X3-1R3                                                  MAL045K
*                            (X7 = CODE FOR HEX)                         MAL045K
          ZR     X5,CFO3                                                 MAL045K
          SB4    CFOD        SET POINTER TO DEC STRING
          SX5    X3-1RD 
          SX7    X7+4        SET CODE FOR DECIMAL 
          ZR     X5,CFO3     IF CHARACTER IS D
          SB4    CFOAL       SET POINTER TO ALPHA STRING                 MAL030K
          SX5    X3-1RA 
          SX7    X7+5        SET CODE FOR ALPHA 
          ZR     X5,CFO3     IF CHARACTER IS A                           MAL030K
          EQ     COM30       ERROR EXIT IF INVALID FIRST CHARACTER
  
*         DETERMINE IF THE EXPECTED CHARACTER STRING IS IN ORDER. EXIT
*         IF NOT.  IF END OF STRING IS FOUND, STORE VALUES FOUND. 
  
 CFO6     SA5    B4          GET EXPECTED CHARACTER 
          BX5    X5-X3
          NZ     X5,CFO7     IF EXPECTED IS NOT ACTUAL
          SA5    F16BIT      16-BIT FLAG
          NZ     X5,CF06A    IF 16-BIT
          SX5    X3-1RA 
          ZR     X5,COM30    ERROR EXIT *OCTA ILLEGAL 
          SX5    X3-1RL 
          ZR     X5,COM30    ERROR EXIT *OCTAL ILLEGAL
          SX5    X3-1RX 
          ZR     X5,COM30    ERROR EXIT *HEX ILLEGAL
          SX5    X3-1RI 
          ZR     X5,COM30    ERROR EXIT *DECI ILLEGAL 
 CF06A    SB4    B4+B1
          SX7    X7+B1       BUMP CODE
          EQ     CFO3        GET NEXT CHARACTER 
 CFO7     SX5    B4-CFOH3                                                MAL045K
          ZR     X5,COM30     *3 IS ILLEGAL FORM                         MAL045K
          SB4    B0           CLEAR * PROCESSING IN PROGRESS FLAG        MAL045K
                                                                         MAL045K
          SA5    B5          GET RESULT WORD
          LX7    B6          POSITION THE CODE TO NEXT POSITION 
          BX7    X7+X5       MERGE IN NEW BYTE
          SA7    A5          RESTORE RESULT WORD
          SB6    B6-13
          PL     B6,CFO2A    IF STILL IN WORD 
          SB5    B5+B1       INCREMENT RESULT WORD
          SB6    39          RESET SHIFT COUNT
          EQ     CFO2A       GET NEXT CHARACTER 
  
 CFOAL    DATA   0           END OF ALPHA STRING                         MAL030K
                                                                         MAL030K
 CFOO     VFD    60/1RC      *OCT CHARACTER STRING
          VFD    60/1RT 
          VFD    60/1RA      16-BIT *OCTA CHARACTER STRING
          VFD    60/1RL 
          DATA   0           END OF STRING
  
 CFOH     VFD    60/1RE      *HE CHARACTER STRING 
          VFD    60/1RX      16-BIT *HEX CHARACTER STRING 
          DATA   0           END OF STRING
  
 CFOH3    VFD    60/1RH       *3H CHARACTER STRING                       MAL045K
          DATA   0            END OF STRING                              MAL045K
                                                                         MAL045K
 CFOD     VFD    60/1RE      *DEC CHARACTER STRING
          VFD    60/1RC 
          VFD    60/1RI      16-BIT *DECI CHARACTER STRING
          DATA   0           END OF STRING
  
  
 CFOA     VFD    42/0,12/77B,6/0     CONTROL WORD FOR STATEMENT NUMBER
          EJECT 
 CSLASH   TITLE  CSLASH - PROCESS / COMMENT CARDS.
**        CSLASH - COMPILE / COMMENT CARDS. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CSLASH- COMPILE / COMMENT CARDS. IF THIS CARD OCCURS WITHIN 
*         THE DATA DIVISION OF THE MODULE, NO ACTION IS ACCOMPLISHED. 
*         IF THE CARD OCCURS BEFORE THE MODULE CARD OR AFTER THE END
*         CARD, A COMPILER ERROR OCCURS.  IF THE CARD OCCURS WITHIN 
*         THE EXECUTABLE CODE DIVISION OF THE MODULE, CODE IS 
*         NOT GENERATED.
* 
*         ENTRY 
* 
*           CRKBUF CONTAINS THE CRACKED SOURCE LINE FROM CRACK. 
* 
*         EXIT
* 
*           . CODE IS STORED INTO THE MODULE BUFFER IF THIS CARD IS IN
*             THE EXECUTABLE CODE DIVISION. 
*           . FCERR FLAG IS SET IF THIS CARD OCCURS OUTSIDE THE MODULE/ 
*             END CARD BOUNDARIES.
* 
*         ROUTINES CALLED -  STOREB  - STORE GENERATED CODE.
* 
*         DATA AREAS USED -  MODULE  - BINARY OF THE CODE GENERATED.
* 
*         USES   A - 1. 
*                X - 0, 1, 6. 
*                B - 2. 
* 
  
 CSLASH   SA1    FCARD
          NZ     X1,COM10          IF THE MODULE CARD HAS BEEN PROCESSED
          SX6    MSG9        OUT OF RANGE ERROR MESSAGE 
          EQ     COM31       ERROR EXIT TO COMPILER 
          EJECT 
 CBLANK   TITLE  CBLANK - PROCESS THE BLANK STATEMENT.
**        CBLANK - COMPILE THE BLANK STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CBLANK - COMPILE THE BLANK STATEMENT.  LEGAL FORMAT OF THIS 
*         STATEMENT IS AS FOLLOWS;
* 
*           BLANK 
*           BLANK PLOT
*           BLANK DISPLAY 
* 
*                       CODE = 1   BLANK PLOT 
*                              2   BLANK DISPLAY
*                              3   BLANK PLOT AND DISPLAY 
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  CSTOREB - STORE GENERATED CODE.
* 
*         DATA AREAS USED -  CRKBUF - WORD STRING OF SOURCE STATEMENT.
*                            MODULE - BINARY PPU CODE GENERATED.
* 
*         USES   A - 1, 2, 3. 
*                X - 0, 1, 2, 3.
*                B - NONE.
* 
  
 CBLANK   SX0    LDN+3       SET CODE FOR BLANK ALL 
          ZR     X3,CBL2     IF END OF STATEMENT
          SA1    DPLOT
          SA2    DDISPLAY 
          SX0    LDN+1       SET CODE FOR BLANK PLOT
          BX1    X3-X1
          ZR     X1,CBL1     IF BLANK PLOT
          BX2    X3-X2
          SX0    X0+B1       SET CODE FOR BLANK DISPLAY 
          NZ     X2,COM30    ERROR EXIT IF NOT PLOT OR DISPLAY
 CBL1     SA3    A3+B1
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
 CBL2     LX0    24 
          SA1    CBLA 
          BX0    X0+X1
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE CODE GENERATED
          EQ     COM10       EXIT TO COMPILER 
  
 CBLA     VFD    36/0,12/RJM,12/BLANK 
          EJECT 
 CCALL    TITLE  CCALL - PROCESS THE CALL STATEMENT.
**        CCALL - COMPILE THE CALL STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CCALL - COMPILE THE CALL STATEMENT.  LEGAL FORMAT OF THIS 
*         STATEMENT IS AS FOLLOWS;
* 
*           CALL Z
* 
*         PARAMETER Z MUST BE A THREE-CHARACTER SUBMODULE NUMBER
*         CONSISTING OF TWO DECIMAL DIGITS FOLLOWED BY AN ALPHA-
*         NUMERIC CHARACTER.
* 
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  CSTOREB - STORE GENERATED CODE.
* 
*         DATA AREAS USED -  CRKBUF - WORD STRING OF SOURCE STATEMENT.
*                            MODULE - BINARY PPU CODE GENERATED.
* 
*         USES   A - 1, 2, 3. 
*                X - 0, 1, 2, 3.
*                B - NONE.
* 
* 
 CCALL    ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SX0    LDN+B1 
          SX1    STD+PA 
          LX0    12 
          BX0    X0+X1       CODE = LDN 1  STD PA 
          RJ     CSTOREB     SAVE CODE GENERATED
          IFEQ   CMSE,0,1 
          RJ     CXREF
          EQ     CEX0        ENTER EXIT COMMAND PROCESSING
          EJECT 
 CCBF     TITLE  CCBF- PROCESS THE COMPARE STATEMENT. 
**        CCBF - COMPILE PPU CODE TO EXECUTE THE COMPARE STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CCBF -COMPILE PPU CODE TO EXECUTE THE COMPARE STATEMENT. THIS 
*               STATEMENT  COMPARES  ONE  BUFFER AREA TO ANOTHER BUFFER 
*               AREA  IN THE FORWARD DIRECTION. 
* 
*         FORMAT FOR THE STATEMENT IS;
* 
*            COMPARE W TO X FOR Y, ABT Z
* 
*             W           X             Y           Z 
*            ---         ---           ---         ---
*            OB           SAME          B0-B15       00-77 (OCTAL)
*            IB           AS            WC
*            SB           W             BA
* 
* 
*         ENTRY  CRKBUF = WORD STRING OF SOURCE STATEMENT.
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  CLOADC - GEN. LOAD CONST. INSTRUCTIONS.
*                            CSTOREB- STORE GENERATED CODE. 
*                            CPSN   - PROCESS THE STATEMENT NUMBERS.
*                            FIND   - FIND THE NEXT ITEM FROM SOURCE. 
* 
*         DATA AREAS USED -  CRKBUF - WORD STRING OF SOURCE STATEMENT.
*                            MODULE - BINARY PPU CODE GENERATED.
* 
*         USES   A - 1, 6, 7. 
*                X - 0, 1, 3, 6, 7. 
*                B - 6, 7.
* 
  
 CCBF     ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SB7    B0 
          SX7    STD+PA 
          SA7    CBFA        STORE THE STORE INSTRUCTION
 CBF1     SA1    B7+CBFCW    LOAD CONTROL WORD
          RJ     FIND        GET ITEM 
          SA1    B7+CBFKW    GET EXPECTED KEYWORD 
          NG     B2,COM31    ERROR EXIT IF ITEM NOT FOUND 
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM NOT EXP VALUE
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP P0INTER TO CRKBUF 
          SB6    B1+B1
          NE     B6,B7,CBF2  IF NOT PROCESSING Y
          SX0    LDN+B3      SET CODE FOR Y = LDN Y 
          EQ     CBF3        CONTINUE SEQUENCE
  
 CBF2     RJ     CLOADC      GENERATE LOAD CONSTANT CODE
 CBF3     SA1    CBFA 
          LX0    12 
          BX0    X0+X1       ADD STD CODE 
          SX6    X1+B1       BUMP STORE ADDRESS 
          SA6    A1          RESTORE STORE INSTRUCTION
          RJ     CSTOREB     SAVE GENERATED CODE
          SB7    B7+B1       ADVANCE COUNTER
          SB6    3
          NE     B7,B6,CBF1  IF ALL ITEMS NOT PROCESSED 
          SA1    B7+CBFCW 
          RJ     FIND        GET Z
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          RJ     CPSN        PROCESS STATEMENT NUMBER 
          SA1    CBFRJM 
          BX0    X1          CODE = LDC 0  RJM CBF
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       EXIT TO COMPILER 
  
*         ORDER OF EXPECTED DATA ITEMS. 
  
 CBFCW    VFD    54/0,3/BUF2,3/0             CONTROL WORD FOR W 
          VFD    54/0,3/BUF2,3/0             CONTROL WORD FOR X 
          VFD    57/0,3/REG1                 CONTROL WORD FOR Y 
          VFD    42/0,12/77B,6/0             CONTROL WORD FOR Z 
  
*         ORDER OF EXPECTED KEYWORDS. 
  
 CBFKW    VFD    60/2LTO
          VFD    60/3LFOR 
          VFD    60/3LABT 
  
 CBFA     DATA   0           BUFFER FOR STORE INSTRUCTION 
 CBFRJM   VFD    12/0,12/LDC,12/0,12/RJM,12/CBF 
          EJECT                                                          MAL011K
 CCHANNL  TITLE  CCHANNL - PROCESS THE CHANNEL PE STATUS COMMAND         MAL011K
**        CCHANNL - PROCESS THE CHANNEL PE STATUS COMMAND                MAL011K
*                                                                        MAL011K
*         K. B. SMITH 78/09/20                                           MAL011K
*                                                                        MAL011K
*         CCHANNL - COMPILE THE CHANNEL PE STATUS STATEMENT.             MAL011K
*                   THIS STATEMENT IS LEGAL ONLY IF COMPILING            MAL011K
*                   FOR OFF-LINE MALET.  FORMAT IS:                      MAL011K
*                                                                        MAL011K
*                CHANNEL PE STATUS TO X, ABT Z                           MAL011K
*                                                                        MAL011K
*                        X          Z                                    MAL011K
*                       ---        ---                                   MAL011K
*                     B0-B15       00-77 (OCTAL)
*                       WC                                               MAL011K
*                       BA                                               MAL011K
*                       OB                                               MAL011K
*                       IB                                               MAL011K
*                                                                        MAL011K
*         ENTRY                                                          MAL011K
*                CRKBUF = WORD STRING OF SOURCE STATEMENT                MAL011K
*                                                                        MAL011K
*         EXIT                                                           MAL011K
*                MODULE = BINARY CODE GENERATED                          MAL011K
*                FCERR IS SET IF AN ERROR IS DETECTED                    MAL011K
*                                                                        MAL011K
*         ROUTINES CALLED - FIND - FIND NEXT ITEM FROM SOURCE            MAL011K
*                                                                        MAL011K
*         DATA AREAS USED - CRKBUF - WORD STRING OF SOURCE STATEMENT     MAL011K
*                           MODULE - BINARY CODE GENERATED               MAL011K
*                                                                        MAL011K
*         USES   A -                                                     MAL011K
*                X -                                                     MAL011K
*                B -                                                     MAL011K
*                                                                        MAL011K
                                                                         MAL011K
 CCHANNL  SA1    FCMSE                                                   MAL011K
          ZR     X1,CCHAN4         ILLEGAL IF NOT COMPILING OFF-LINE     MAL029K
          RJ     CSETP             GENERATE CODE TO SET P REGISTER       MAL011K
          SA1    DPE                                                     MAL011K
          BX1    X3-X1                                                   MAL011K
          NZ     X1,COM30          ERROR OF NEXT ITEM IS NOT -PE-        MAL011K
          SA3    A3+B1                                                   MAL011K
          SA1    DSTATUS                                                 MAL011K
          BX1    X3-X1                                                   MAL011K
          NZ     X1,COM30          ERROR IF NEXT ITEM IS NOT -STATUS-    MAL011K
          SA3    A3+B1                                                   MAL011K
          SA1    DTO                                                     MAL011K
          BX1    X3-X1                                                   MAL011K
          NZ     X1,COM30          ERROR IF NEXT ITEM IS NOT -TO-        MAL011K
          SA1    CCHANA                                                  MAL011K
          BX0    X1                CODE = LDN  2    STD  PA              MAL011K
          RJ     CSTOREB           STORE CODE GENERATED                  MAL011K
          SA3    A3+B1                                                   MAL011K
          ZR     X3,COM30          ERROR IF END OF STATEMENT             MAL011K
          SX6    A3                                                      MAL011K
          SA6    PCRK              UPDATE POINTER TO CRKBUF              MAL011K
          SA1    CRSW                                                    MAL011K
          RJ     FIND              FIND X                                MAL011K
          NG     B2,COM31          ERROR IF NOT LEGAL X                  MAL011K
          SX7    B2                                                      MAL011K
          LX7    18                                                      MAL011K
          SX1    B3                                                      MAL011K
          BX7    X7+X1                                                   MAL011K
          LX7    18                                                      MAL011K
          BX7    X7+X2                                                   MAL011K
          SA7    CRSSW             SAVE X(B2,B3,X2)                      MAL011K
          NZ     B2,CCHAN1         IF NOT BUFFER(REGISTER)               MAL011K
          RJ     CLOADC            GENERATE LOAD CONSTANT CODE           MAL011K
          SA1    TESTWC                                                  MAL011K
          BX0    X1                                                      MAL011K
          RJ     CABSPPU           ABLOSUTIZE PPU ADDRESSES              MAL011K
          RJ     CSTOREB           STORE CODE GENERATED                  MAL011K
 CCHAN1   SA1    CFZCPB                                                  MAL011K
          ZR     X3,CCHAN3         IF END OF STATEMENT                   MAL011K
          SA1    DABT                                                    MAL011K
          BX1    X3-X1                                                   MAL011K
          NZ     X1,COM30          ERROR IF NEXT ITEM NOT -ABT-          MAL011K
          SA3    A3+B1                                                   MAL011K
          ZR     X3,COM30          ERROR IF END OF STATEMENT             MAL011K
          SX6    A3                                                      MAL011K
          SA6    PCRK              UPDATE POINTER TO CRKBUF              MAL011K
          SA1    CGOW                                                    MAL011K
          RJ     FIND              GET ABT STATEMENT NUMBER              MAL011K
          NG     B2,COM31          ERROR IF NOT FOUND                    MAL011K
          NZ     X3,COM30          ERROR IF NOT END OF STATEMENT         MAL011K
          RJ     CPSN              PROCESS STATEMENT NUMBER              MAL011K
          SA1    CFZCPA                                                  MAL011K
 CCHAN3   BX0    X1                CODE = LDC/N 0 RJM TFZCP              MAL011K
          RJ     CABSPPU           ABSOLUTIZE PPU ADDRESS                MAL011K
          RJ     CSTOREB           STORE GENERATED CODE                  MAL011K
          SA1    CRSSW             RESTORE X                             MAL011K
          MX2    42                                                      MAL011K
          BX2    -X2*X1                                                  MAL011K
          AX1    18                                                      MAL011K
          SB3    X1                                                      MAL011K
          AX1    18                                                      MAL011K
          SB2    X1                                                      MAL011K
          RJ     CSTORE            GENERATE STORE TO X CODE              MAL011K
          RJ     CSTOREB           SAVE GENERATED CODE                   MAL011K
          EQ     COM10             RETURN TO COMPILER                    MAL011K
                                                                         MAL029K
 CCHAN4   SX6    MSG18             UNRECOGNIZED STATEMENT                MAL029K
          EQ     COM31             ERROR EXIT                            MAL029K
                                                                         MAL011K
 CCHANA   VFD    36/0,12/LDN+2,12/STD+PA                                 MAL011K
          EJECT 
 CCOPY    TITLE  CCOPY- PROCESS THE COPY STATEMENT. 
**        CCOPY - COMPILE PPU CODE TO EXECUTE THE COPY STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         THIS STATEMENT MOVES ONE BUFFER AREA TO ANOTHER BUFFER AREA.
* 
*         FORMATS FOR THE ABOVE STATEMENTS IS AS FOLLOWS..
* 
*                 COPY X TO Y FOR Z 
* 
*         VALUES FOR THE PARAMETERS ABOVE ARE AS FOLLOWS... 
* 
*                  X               Y                Z 
*                 ---             ---              ---
*                  OB             OB              ANY REG.
*                  IB             IB              ANY LEGAL 
*                  SB                             CONSTANT. 
* 
*         ENTRY  CRKBUF = WORD STRING OF SOURCE STATEMENT.
*                X0 = 0.
* 
*         EXIT   MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE. 
*                FCERR COMPILER ERROR FLAG SET IF COMPILER ERR CREATED. 
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CLOAD  - GEN. LOAD INSTRUCTIONS. 
*                            CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF - WORD STRING OF SOURCE STATEMENT.
*                            MODULE - BINARY PPU CODE GENERATED.
* 
*         USES   A - 1, 6.
*                X - 0, 1, 3, 6.
*                B - NONE.
* 
  
 CCOPY    ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          RJ     CSETP             GENERATE CODE TO SET P 
          SA1    COPX 
          RJ     FIND        GET X
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SA1    DTO
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT TO
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          RJ     CLOADC      GENERATE LOAD X VALUE CODE 
          SX0    STD+PA+2    ADD STD CODE 
          RJ     CSTOREB     SAVE GENERATED CODE
          SA1    COPXY
          RJ     FIND        GET Y
          SA1    DFOR 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT FOR 
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          RJ     CLOADC      GENERATE LOAD Y VALUE CODE 
          SX0    STD+PA      ADD STD CODE 
          RJ     CSTOREB     STORE GENERATED CODE 
          SA1    COPZ 
          RJ     FIND        GET Z
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT EOS 
          RJ     CLOAD       GENERATE LOAD Z CODE 
          SA1    RJMCOPY
          BX0    X1 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     STORE GENERATED CODE 
          EQ     COM10       RETURN TO COMPILER 
  
  
 COPX     VFD    54/0,3/BUF2,3/0              CONTROL WORD FOR X
 COPXY    VFD    54/0,3/BUF1,3/0              CONTROL WORD FOR Y
 COPZ     VFD    42/0,12/500B,3/0,3/REG2      CONTROL WORD FOR Z
 RJMCOPY  VFD    36/0,12/RJM,12/COPY
          EJECT 
 CDELAY   TITLE  CDELAY- PROCESS DELAY STATEMENT. 
**        CDELAY- PROCESS DELAY STATEMENT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CDELAY - COMPILE PPU CODE FOR THE DELAY STATEMENT. THE LEGAL
*                  FORMAT FOR THIS STATEMENT IS AS FOLLOWS; 
* 
*                DELAY X MSEC         MILLISECONDS DELAY
*                DELAY X USEC         MICROSECONDS DELAY
* 
*                             X 
*                            ---
*                          ANY REG. 
*                          ANY LEGAL
*                          CONSTANT.
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CLOAD  - GEN. LOAD INSTRUCTIONS. 
*                            CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF - WORD STRING OF SOURCE STATEMENT.
*                            MODULE - BINARY PPU CODE GENERATED.
*                            PCRK   - POINTER TO CRACK BUFFER.
*                            CDLX   - CONTROL WORD FOR X. 
*                            CDLA   - PPU CODE FOR RJM DELAY. 
* 
*         USES   A - 1, 2.
*                X - 0, 1, 2, 5.
*                B - NONE.
* 
  
 CDELAY   ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CDL0     IF NOT 16-BIT
          SA1    CDLX16 
          EQ     CDL0A
 CDL0     SA1    CDLX 
 CDL0A    RJ     FIND        GET DELAY COUNT
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          RJ     CLOAD       GENERATE LOAD X CODE 
          SA1    DUSEC
          SA2    DMSEC
          BX5    X3-X2
          ZR     X5,CDL1     IF MILLISECOND DELAY 
          BX5    X3-X1
          NZ     X5,COM30    ERROR EXIT IF NOT MICROSECOND DELAY
          SX0    ADC+40B
          LX0    12          SET SIGN BIT TO FLAG MICROSECOND DELAY 
 CDL1     SA1    CDLA 
          LX0    24 
          BX0    X0+X1       CODE =  RJM DELAY
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          SA1    PCRK 
          SA1    X1+B1
          NZ     X1,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       RETURN TO COMPILER 
  
 CDLX     VFD    42/0,12/7777B,3/0,3/REG2   CONTROL WORD FOR X
 CDLX16   VFD    21/0,6/17B,15/0,12/7777B,3/0,3/REG2  16-BIT CONT. X
 CDLA     VFD    36/0,12/RJM,12/DELAY 
          EJECT 
 CDUP     TITLE  CDUP - PROCESS DUP STATEMENT.
**        CDUP - PROCESS DUP STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CDUP - COMPILE PPU CODE FOR THE DUP SOURCE STATEMENT. THIS
*         STATEMENT DUPLICATE A SINGLE WORD TO A BUFFER AREA. 
*         FORMATS FOR THE STATEMENT ARE AS FOLLOWS; 
*              DUP W TO Y FOR Z 
*              DUP W/X TO Y FOR Z 
*              DUP V BITS OF W TO Y FOR Z 
*              DUP V BITS OF W/X TO Y FOR Z 
* 
*         VALUES FOR THE ABOVE PARAMETERS ARE AS FOLLOWS..
* 
*              V      W AND/OR X       Y        Z 
*             ---    ------------     ---      ---
*          ANY REG.      OB           OB     ANY REG. 
*          10 (OCTAL)    IB           IB    ANY LEGAL 
*      **6,14 (OCTAL)    SB                 CONSTANT. 
*         *20 (OCTAL)  ANY REG. 
*                      ANY LEGAL
*                      CONSTANT.
* 
*         *  ILLEGAL WHEN KEYWORD 16BIT IS OMITTED FROM THE MODULE CARD.
*         ** ILLEGAL WHEN KEYWORD 16BIT IS PRESENT IN THE MODULE CARD.
* 
*         ENTRY CRKBUF = WORD STRING OF DUP STATEMENT 
*               X0 = 0. 
* 
*         EXIT  MODULE = PPU BINARY CODE GENERATED FOR THIS DUP.
*               FCERR COMPILER ERROR FLAG IS SET IF THIS DUP CREATED AN 
*               ERROR.
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CLOAD  - GEN. LOAD INSTRUCTIONS. 
*                            CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF DUP SOURCE. 
*                            MODULE- BINARY PPU CODE STORED HERE. 
* 
*         USES   A - 1, 3, 4, 6.
*                X - 0, 1, 2, 3, 4, 6.
*                B - 2, 7.
* 
  
 CDUP     RJ     CSETP             GENERATE CODE TO SET P 
          SB2    3                 OCTAL CODE FOR CLOAD 
          SX2    12          DEFAULT VALUE FOR V
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CDUP1    IF NOT 16-BIT
          SX2    16          16-BIT DEFAULT VALUE FOR V 
 CDUP1    SB7    STD+PA+2 
          ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SA1    PCRK 
          SA3    X1+B1
          SA1    DBITS
          BX3    X3-X1
          NZ     X3,CDU1     IF NEXT ITEM IN CRKBUF IS NOT BITS 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CDUP2    IF NOT 16-BIT
          SA1    CDUV16      16-BIT CONTROL WORD FOR V
          EQ     CDUP3       SEARCH FOR V 
  
 CDUP2    SA1    CDUV        12-BIT CONTROL WORD FOR V
 CDUP3    RJ     FIND        SEARCH FOR V 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SX6    MSG3        OUT OF RANGE MESSAGE IN CASE OF ERROR
          ZR     X2,COM31    ERROR EXIT IF V IS ZERO
          SX1    B1+B1
          SX3    B2 
          BX3    X1-X3
          ZR     X3,CDU0           IF REGISTER FOUND
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CDUP4    IF NOT 16-BIT
          SX1    6
          BX3    X1-X2
          ZR     X3,COM31    ERROR IF VALUE IS 6
          LX1    1
          BX3    X1-X2
          ZR     X3,COM31    ERROR IF VALUE IS 12 
          SX1    8
          BX3    X1-X2
          ZR     X3,CDU0     LEGAL VALUE OF 8 
          LX1    1
          BX3    X1-X2
          NZ     X3,COM31    ERROR IF VALUE IS NOT 8 OR 16
          EQ     CDU0        LEGAL VALUE OF 16
  
 CDUP4    SX1    16 
          BX3    X1-X2
          ZR     X3,COM31    ERROR IF VALUE IS 16 
          SX1    6
          BX3    X1-X2
          ZR     X3,CDU0           IF VALUE IS 6
          LX1    1
          BX3    X1-X2
          ZR     X3,CDU0
          SX1    8
          BX3    X1-X2
          NZ     X3,COM31          IF VALUE IS NOT 6,8 OR 12
 CDU0     SA1    PCRK 
          SA3    X1+B1
          SA4    DOF
          BX3    X3-X4
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT OF
          SX6    A3+B1
          SA6    A1          BUMP POINTER TO CRKBUF BY 2
 CDU1     RJ     CLOAD       GENERATE LOAD V CODE 
          SX0    B7 
          SB7    B7+B1       BUMP STORAGE ADDRESS 
          SA1    CDUW 
          RJ     FIND        GET W
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          RJ     CLOAD       GENERATE LOAD W CODE 
          SX0    B7 
          RJ     CSTOREB     STORE GENERATED CODE 
          SB7    B7+B1       BUMP STORAGE ADDRESS 
          SX1    X3-1R/ 
          NZ     X1,CDU1B          IF NEXT ITEM NOT / 
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1                BUMP POINTER TO CRKBUF 
          SA1    CDUX 
          RJ     FIND        GET X
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          RJ     CLOAD             GENERATE LOAD X CODE 
 CDU1B    SX0    B7 
          SA1    DTO
          BX1    X3-X1
          NZ     X1,COM30          IF NEXT ITEM IS NOT TO 
          SB7    STD+PA 
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1 
          SA1    CDUY 
          RJ     FIND        GET Y
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          RJ     CLOADC            GENERATE LOAD Y VALUE CODE 
          SX0    B7 
          SA1    DFOR 
          BX1    X3-X1
          NZ     X1,COM30          IF NEXT ITEM IS NOT FOR
          SA1    PCRK 
          SX6    X1+B1
          SA6    PCRK        BUMP POINTER TO CRKBUF 
          SA1    CDUZ 
          RJ     FIND        GET Z
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SX6    MSG3        OUT OF RANGE MESSAGE IN CASE OF ERROR
          ZR     X2,COM31    ERROR EXIT IF Z IS ZERO
          NZ     X3,COM30          IF NOT END OF STATEMENT
 CDU2     RJ     CLOAD       GENERATE LOAD Z CODE 
          SA1    RJMDUP 
          BX0    X1 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     STORE GENERATED CODE 
          EQ     COM10       RETURN TO COMPILER 
  
 CDUV     VFD    42/0,12/14B,3/0,3/REG2           CONTROL WORD FOR V
 CDUV16   VFD    42/0,12/20B,3/0,3/REG2    16-BIT CONTROL WORD FOR V
 CDUW     VFD    21/0,6/17B,15/0,12/7777B,3/BUF2,3/REG2   W CONTROL WORD
 CDUX     VFD    21/0,6/17B,15/0,12/7777B,3/BUF2,3/REG2   X CONTROL WORD
 CDUY     VFD    54/0,3/BUF1,3/0                  CONTROL WORD FOR Y
 CDUZ     VFD    21/0,6/17B,15/0,12/7777B,3/0,3/REG2      Z CONTROL WORD
 RJMDUP   VFD    36/0,12/RJM,12/DUP 
          EJECT 
 CEND     TITLE  CEND - PROCESS THE END STATEMENT.
**        CEND - PROCESS THE END STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CEND - COMPILE THE END STATEMENT.  FORMATS ARE AS FOLLOWS;
* 
*                END X
* 
*                             X 
*                            ---
*                          00 - 77 (OCTAL)
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
*           . MODULE HEADER IS MODIFIED TO INCLUDE ENTRY POINT DATA.
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USE  -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1, 6.
*                X - 0, 1, 2, 6.
*                B - NONE.
* 
 CEND     SA1    PSOURCE
          SX6    X1+6 
          SA6    MSOURCE     SET END OF SOURCE TO THIS LINE PLUS ONE
          ZR     X3,COM30    EXIT IF END OF STATEMENT 
          IFEQ   CMSE,0 
          MX1    1
          LX1    18 
          BX3    X1+X3             FLAG REFERENCE NOT FOR GLOBAL MAP
          RJ     CXREF
          ENDIF 
          SA1    CGOW 
          RJ     FIND        GET STATEMENT NUMBER 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          SA1    X2+CSN      GET LINE NUMBER AND ADDRESS OF SN
          SX6    MSG5 
          ZR     X1,COM31    ERROR EXIT IF STATEMENT NO. IS UNDEFINED 
          NG     X1,COM31    ERROR EXIT IF DATA DIVISI0N STATEMENT NO.
          SX6    X1 
          SX2    3777B
          AX6    11          LINE NUMBER OF STARTING ADDRESS
          BX2    X2*X1       PPU ADDRESS
          SX1    177B        MASK FOR LINE NUMBER 
          BX6    X6*X1
          LX6    12 
          SA1    MODULE+5 
          BX6    X6+X2       LINE NUMBER AND PPU ADDRESS
          LX6    36 
          BX6    X6+X1       MERGE OLD AND NEW HEADER DATA
          SA6    A1          RESTORE DATA IN HEADER 
          SA6    FEND        SET END CARD FLAG
          SA1    CENA 
          BX0    X1          CODE = RJM END 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       RETURN TO COMPILER TO TERMINATE COMPILE
  
 CENA     VFD    36/0,12/LJM,12/END 
          EJECT 
 CENDSUB  TITLE  CENDSUB - PROCESS THE ENDSUB STATEMENT.
**        CENDSUB - COMPILE PPU CODE FOR THE ENDSUB STATEMENT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CENDSUB - COMPILE PPU CODE FOR THE ENDSUB STATEMENT. THE
*         FORMATS FOR THIS STATEMENT IS AS FOLLOWS; 
* 
*                ENDSUB 
*                ENDSUB GOTO W
* 
*                             W 
*                            ---
*                          00 - 77 (OCTAL)
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CPSN   - PROCESS THE STATEMENT NUMBERS.
*                            CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USE  -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1, 6.
*                X - 0, 1, 2, 6.
*                B - NONE.
* 
  
 CENDSUB  NZ     X3,CES1     IF NOT END OF STATEMENT
          SX0    LDN
          SA1    CESA 
          MX2    -24
          BX1    -X2*X1 
          LX0    24 
          BX0    X0+X1
          EQ     CES2 
  
 CES1     SA1    DGOTO
          BX2    X3-X1
          NZ     X2,COM30    ERROR EXIT IF NEXT ITEM IS NOT GOTO
          SX6    B1 
          SA6    ZXFER             SET TRANSFER FLAG
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          SA1    CGOW 
          RJ     FIND        GET STATEMENT NUMBER 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          RJ     CPSN        PROCESS STATEMENT NUMBER 
          SA1    CESA 
          BX0    X1          CODE = LDC 0  RJM ENDSUB 
 CES2     RJ     CABSPPU           ABSOLUTIZE PPU ADDRESSES 
          RJ     CSTOREB           SAVE GENERATED CODE
          EQ     COM10       RETURN TO COMPILER 
  
 CESA     VFD    12/0,12/LDC,12/0,12/RJM,12/ENDSUB
          EJECT 
 CERROR   TITLE  CERROR - PROCESS THE ERROR STATEMENT.
**        CERROR - PROCESS THE ERROR STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CERROR - COMPILE THE ERROR STATEMENT.  FORMATS OF THIS
*         STATEMENT IS AS FOLLOWS;
* 
*                ERROR X/Y
*                ERROR X/Y, GOTO Z
*                ERROR X/Y, GOSUB Z 
* 
*                  X                 Y                    Z 
*                 ---               ---                  ---
*               00 - 77 (OCTAL)    0 - 3777 (OCTAL)   00 - 77 (OCTAL) 
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CSTOREB- STORE GENERATED CODE. 
*                            CPSN   - PROCESS THE STATEMENT NUMBERS.
* 
*         DATA AREAS USE  -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1, 2, 6. 
*                X - 0, 1, 2, 6.
*                B - 7. 
* 
  
 CERROR   ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          RJ     CSETP             GENERATE CODE TO SET P 
          IFEQ   CMSE,0,1 
          RJ     CXREF
          SA1    CIFA 
          RJ     FIND        GET ERROR MESSAGE A
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SX3    X3-1R/ 
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT / 
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          SX0    X2+LDC      SAVE ERROR MESSAGE A 
          SA1    CIFB 
          RJ     FIND        GET ERROR NUMBER B 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          LX0    12 
          BX0    X0+X2       CODE = LDC A/B 
          SA1    RJMERR 
          LX0    24 
          BX0    X0+X1       CODE = LDC A/B  RJM ERROR
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          NZ     X3,CER1     IF NOT END OF STATEMENT
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       EXIT TO COMPILER 
  
 CER1     RJ     CSTOREB     SAVE GENERATED CODE
          SA1    DGOTO
          SA2    DGOSUB 
          SB7    B0          CLEAR FLAG 
          BX1    X1-X3
          ZR     X1,CER2     IF GOTO
          BX2    X2-X3
          NZ     X2,COM30    ERROR EXIT IF NEXT ITEM NOT GOTO OR GOSUB
          SB7    B1 
          EQ     CER3 
 CER2     SX6    B1 
          SA6    ZXFER             SET TRANSFER FLAG
 CER3     SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          SA1    CIFZ 
          RJ     FIND        GET Z
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          RJ     CPSN        PROCESS STATEMENT NUMBER 
          SA1    CERA+B7     GET CODE BASED ON FLAG 
          BX0    X1 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
 CER4     RJ     CSTOREB           SAVE GENERATED CODE
          EQ     COM10       RETURN TO COMPILER 
  
*         WORDS BELOW ARE ORDER DEPENDANT 
  
  
 CERA     VFD    12/0,12/LDC,12/0,12/LJM,12/RNI 
          VFD    12/0,12/LDC,12/0,12/RJM,12/GOSUB 
          EJECT 
 CEXIT    TITLE  CEXIT - PROCESS THE EXIT STATEMENT.
**        CEXIT - PROCESS THE EXIT STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CEXIT - COMPILE THE EXIT STATEMENT.  FORMATS ARE
*         AS FOLLOWS; 
* 
*                EXIT 
*                EXIT TO X
* 
*                PARAMETER X MUST BE A THREE-CHARACTER SUBMODULE NUMBER 
*                CONSISTING OF TWO DECIMAL DIGITS FOLLOWED BY AN ALPHA- 
*                NUMERIC CHARACTER. 
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USE  -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1, 3.
*                X - 0, 1, 2, 3, 4. 
*                B - NONE.
* 
  
 CEXIT    SX6    B1 
          SA6    ZXFER             SET TRANSFER FLAG
          SX0    LDN
          SX1    STD+PA 
          LX0    12 
          BX0    X0+X1       CODE = LDN 0   STD  PA 
          RJ     CSTOREB     SAVE GENERATED CODE
          ZR     X3,CEX1     IF END OF STATEMENT
          SA1    DTO
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT TO
          SA3    A3+B1       GET MODULE NUMBER REQUESTED
          IFEQ   CMSE,0,1 
          RJ     CXREF
 CEX0     MX2    18 
          BX1    -X2*X3 
          NZ     X1,COM30    ERROR EXIT IF GREATER THAN 3 DIGITS
          LX3    6
          SX1    77B
          BX2    X3*X1       FIRST DIGIT OF MODULE NUMBER 
          SX4    X2-1R0 
          NG     X4,COM30    ERROR EXIT IF NOT A NUMBER 
          SX4    X2-1R9-1 
          PL     X4,COM30    ERROR EXIT IF NOT A NUMBER 
          LX3    6
          BX2    X3*X1
          SX4    X2-1R0 
          NG     X4,COM30    ERROR EXIT IF NOT A NUMBER 
          SX4    X2-1R9-1 
          PL     X4,COM30    ERROR EXIT IF NOT A NUMBER 
          LX3    6           ADD IN SUBMODULE NUMBER
          BX2    X3*X1
          ZR     X2,COM30    ERROR EXIT IF NOT A 3 DIGIT MODULE NUMBER
          SX4    LDC
          LX4    12 
          BX0    X4+X3       CODE = LDC MODULE NUMBER 
          SA3    A3+B1
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
 CEX1     SA1    CEXA 
          LX0    24 
          BX0    X0+X1       CODE = LOAD MODULE  RJM EXIT 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       RETURN TO COMPILER 
  
 CEXA     VFD    36/0,12/RJM,12/EXIT
          EJECT                                                          MAL011K
 CFZCP    TITLE  CFZCP - PROCESS THE FZCP STATEMENT                      MAL011K
**        CFZCP - PROCESS THE FZCP STATEMENT                             MAL011K
*                                                                        MAL011K
*         K. B. SMITH 78/09/20                                           MAL011K
*                                                                        MAL011K
*         CFZCP - COMPILE THE FZCP STATEMENT.  THIS STATEMENT IS         MAL011K
*                 LEGAL ONLY IF COMPILING FOR OFF-LINE MALET.            MAL011K
*                 FORMATS ARE AS FOLLOWS:                                MAL011K
*                                                                        MAL011K
*                FZCP,ON,ABT Z                                           MAL011K
*                FZCP,OFF,ABT Z                                          MAL011K
*                FZCP,ON                                                 MAL011K
*                FZCP,OFF                                                MAL011K
*                             Z                                          MAL011K
*                            ---                                         MAL011K
*                          00 - 77 (OCTAL)
*                                                                        MAL011K
*         ENTRY                                                          MAL011K
*                CRKBUF = WORD STRING OF SOURCE STATEMENT                MAL011K
*                                                                        MAL011K
*         EXIT                                                           MAL011K
*                MODULE = BINARY CODE GENERATED FOR THE STATEMENT        MAL011K
*                FCERR IS SET IF AN ERROR IS DETECTED                    MAL011K
*                                                                        MAL011K
*         ROUTINES CALLED                                                MAL011K
*                         - FIND    - FIND NEXT ITEM FROM SOURCE         MAL011K
*                         - CSTOREB - STORE GENERATED CODE               MAL011K
*                                                                        MAL011K
*         DATA AREAS USED - CRKBUF - WORD STRING OF SOURCE STATEMENT     MAL011K
*                           MODULE - BINARY CODE GENERATED               MAL011K
*                                                                        MAL011K
*         USES   A -                                                     MAL011K
*                X -                                                     MAL011K
*                B -                                                     MAL011K
*                                                                        MAL011K
                                                                         MAL011K
 CFZCP    SA1    FCMSE                                                   MAL011K
          ZR     X1,CFZCP4   ILLEGAL IF NOT COMPILING FOR OFF-LINE       MAL029K
          RJ     CSETP             GENERATE CODE TO SET P REGISTER       MAL011K
          SX0    LDN               CODE = LDN 0                          MAL011K
          SA1    DON                                                     MAL011K
          BX1    X3-X1                                                   MAL011K
          ZR     X1,CFZCP1         IF NEXT ITEM IS -ON-                  MAL011K
          SA1    DOFF                                                    MAL011K
          BX1    X3-X1                                                   MAL011K
          NZ     X1,COM30          IF NEXT ITEM IS NOT -OFF-             MAL011K
          SX0    X0+B1             CODE = LDN 1                          MAL011K
 CFZCP1   LX0    12                                                      MAL011K
          SX1    STD+PA            CODE = STD PA                         MAL011K
          BX0    X0+X1                                                   MAL011K
          RJ     CSTOREB           STORE GENERATED CODE                  MAL011K
          SA3    A3+B1             NEXT ITEM FROM CRKBUF                 MAL011K
          SA1    CFZCPB                                                  MAL011K
          ZR     X3,CFZCP3         IF END OF STATEMENT                   MAL011K
          SA1    DABT                                                    MAL011K
          BX1    X3-X1                                                   MAL011K
          NZ     X1,COM30          ERROR IF NEXT ITEM NOT -ABT-          MAL011K
          SA3    A3+B1                                                   MAL011K
          ZR     X3,COM30          ERROR IF END OF STATEMENT             MAL011K
          SX6    A3                                                      MAL011K
          SA6    PCRK              UPDATE POINTER TO CRKBUF              MAL011K
          SA1    CGOW                                                    MAL011K
          RJ     FIND              GET ABT STATEMENT NUMBER              MAL011K
          NG     B2,COM31          ERROR IF NOT FOUND                    MAL011K
          NZ     X3,COM30          ERROR IF NOT END OF STATEMENT         MAL011K
          RJ     CPSN              PROCESS STATEMENT NUMBER              MAL011K
          SA1    CFZCPA                                                  MAL011K
 CFZCP3   BX0    X1                CODE = LDC/N 0 RJM TFZCP              MAL011K
          RJ     CABSPPU           ABSOLUTIZE PPU ADDRESS                MAL011K
          RJ     CSTOREB           SAVE GENERATED CODE                   MAL011K
          EQ     COM10             RETURN TO COMPILER                    MAL011K
                                                                         MAL029K
 CFZCP4   SX6    MSG18       UNRECOGNIZED STATEMENT                      MAL029K
          EQ     COM31       ERROR EXIT                                  MAL029K
                                                                         MAL011K
 CFZCPA   VFD    12/0,12/LDC,12/0,12/RJM,12/TFZCP                        MAL011K
 CFZCPB   VFD    24/0,12/LDN,12/RJM,12/TFZCP                             MAL011K
          EJECT 
 CGOSUB   TITLE  CGOSUB - PROCESS THE GOSUB STATEMENT.
**        CGOSUB - PROCESS THE GOSUB STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CGOSUB - COMPILE PPU CODE FOR THE GOSUB STATEMENT.
*         FORMAT FOR THE STATEMENT IS AS FOLLOWS; 
* 
*              GOSUB W
* 
*                             W 
*                            ---
*                          00 - 77 (OCTAL)
* 
*         PARAMETER W IS A LEGAL STATEMENT NUMBER.
* 
*         ENTRY  CRKBUF = WORD STRING OF SOURCE STATEMENT.
* 
*         EXIT   MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE. 
*                FCERR COMPILER ERROR FLAG SET IF COMPILER ERR CREATED. 
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CSTOREB- STORE GENERATED CODE. 
*                            CPSN   - PROCESS THE STATEMENT NUMBERS.
* 
*         DATA AREAS USE  -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1. 
*                X - 0, 1.
*                B - NONE.
* 
 CGOSUB   ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          RJ     CSETP       GENERATE CODE TO SET P REGISTER
          SA1    CGOW 
          RJ     FIND        GET STATEMENT NUMBER W 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          RJ     CPSN        PROCESS STATEMENT NUMBER 
          SA1    CGSA 
          BX0    X1          CODE = LDC 0  RJM GOSUB  AOD P 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       RETURN TO COMPILER 
  
 CGSA     VFD    12/0,12/LDC,12/0,12/RJM,12/GOSUB 
          EJECT 
 CGOTO    TITLE  CGOTO - PROCESS THE GOTO STATEMENT.
**        CGOTO - PROCESS THE GOTO STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CGOTO - COMPILE PPU CODE FOR THE GOTO STATEMENT.  LEGAL 
*         FORMATS FOR THIS STATEMENT ARE AS FOLLOWS...
* 
*             GOTO W
*             GOTO W WHILE ( X OP Y COND Z )
* 
*         VALUES FOR THE PARAMETERS ABOVE ARE AS FOLLOWS..
* 
*                W              X      OP      Y         COND    Z
*               ---            ---    ----    ---        ----   --- 
*             00-77 (OCTAL)   B0-B7     +    ANY BUF.     EQ   ANY BUF. 
*                               WC      -    ANY REG.     NE   ANY REG. 
*                               BA           EXCEPT RT    LT   EXCEPT RT
*                                            ANY LEGAL    GT   ANY LEGAL
*                                            CONSTANT.    LE   CONSTANT.
*                                                         GE
* 
* 
*         ENTRY   CRKBUF = WORD STRING OF CURRENT GOTO STATEMENT. 
*                 X0 = 0. 
* 
*         EXIT    MODULE = BINARY PPU CODE GENERATED BY THIS GOTO.
*                 FCERR IS SET IF A COMPILER ERROR OCCURRED ON THIS 
*                 STATEMENT.
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CSTOREB-STORE GENERATED CODE.
*                            CPSN   - PROCESS THE STATEMENT NUMBERS.
*                            CLOAD  - GEN. LOAD INSTRUCTIONS. 
*                            CADD   - GEN. ADD INSTRUCTIONS.
*                            CMINUS - GEN. SUBTRACT INSTRUCTIONS. 
*                            CEQ    - GEN. EQ INSTRUCTIONS. 
*                            CNE    - GEN. NE INSTRUCTIONS. 
*                            CLT    - GEN. LT INSTRUCTIONS. 
*                            CGT    - GEN. GT INSTRUCTIONS. 
*                            CLE    - GEN. LE INSTRUCTIONS. 
*                            CGE    - GEN. GE INSTRUCTIONS. 
* 
*         DATA AREAS USE  -   CRKBUF- WORD STRING OF SOURCE STATEMENT.
*                             MODULE- CONTAINS BINARY CODE GENERATED. 
* 
*         USES   A - 1, 2, 3, 4, 6. 
*                X - 0, 1, 2, 3, 4, 6, 7. 
*                B - 6, 7.
* 
  
 CGOTO    ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SX6    B1 
          SA6    ZXFER             SET TRANSFER FLAG
          SA1    CGOW 
          RJ     FIND        GET STATEMENT NUMBER  W
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          NZ     X3,CGO1     IF NOT END OF STATEMENT
          RJ     CPSN        PROCESS STATEMENT NUMBER TO LINES BUFFER 
          SA1    CGOA 
          BX0    X1 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     STORE CODE IN MODULE BUFFER
          EQ     COM10       RETURN TO COMPILER 
  
 CGO1     BX6    X2 
          SA6    CGOSN       SAVE STATEMENT NUMBER
          MX6    0                                                       MAL009K
          SA6    ZXFER             CLEAR UNCONDITIONAL TRANSFER FLAG     MAL009K
          SA1    DWHILE 
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT WHILE 
          SA4    PCRK 
          SA2    X4+B1       READ NEXT CRKBUF ITEM
          SX3    X2-1R( 
          NZ     X3,COM30    ERROR EXIT IF IT IS NOT (
          SX6    A2+B1
          SA6    A4          BUMP POINTER TO CRKBUF 
          SA1    CGOX 
          RJ     FIND        GET X
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SX6    B3 
          SA6    CGOXX       SAVE VALUE OF X
          RJ     CLOAD       GENERATE LOAD X CODE 
          SA1    CGOOP
          RJ     FIND        GET OP 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SB7    B2          SAVE OP ENTRY ADDRESS
          SA1    CGOY 
          RJ     FIND        GET Y
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SB6    X2-1 
          NZ     B6,CGO1A    IF Y IS NOT 1
          SA1    CGOXX       GET VALUE FOR X
          SX0    AOD+X1      FORM +1 CODE 
          SX2    LDD+X1      AND LOAD CODE
          SB6    B7-CADD
          ZR     B6,CGO2A    IF + 1 
          SX0    SOD+X1      IF - 1 
          EQ     CGO2A
  
 CGO1A    SB6    CGO2        RETURN ADDRESS 
          JP     B7          ENTER OP ROUTINE 
  
 CGO2     SA1    CGOXX       RELOAD X 
          LX0    12          PREPARE FOR STD CODE 
          SX2    X1+LDD 
          SX1    X1+STD 
          BX0    X0+X1       ADD STD REGISTER CODE
 CGO2A    LX0    12 
          BX0    X0+X2       ADD LDD REG CODE 
          RJ     CSTOREB     SAVE GENERATED CODE IN MODULE BUFFER 
          SA1    CGOCOND
          RJ     FIND        GET COND 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SB7    B2          SAVE COND ROUTINE ENTRY ADDRESS
          SA1    CGOZ 
          RJ     FIND        GET Z
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SX3    X3-1R) 
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IF NOT ) 
          SA1    PCRK 
          SA3    X1+B1
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STRING
          SB6    CGO3        RETURN ADDRESS 
          EQ     CMINUS      GENERATE - Y CODE
  
 CGO3     SB6    CGO4        RETURN ADDRESS 
          SX7    5           NUMBER OF BYTES TO BE JUMPED AROUND
          JP     B7          ENTER COND ROUTINE 
  
 CGO4     RJ     CSTOREB     SAVE CODE IN MODULE BUFFER 
          SA2    CGOSN
          RJ     CPSN        PROCESS STATEMENT NUMBER TO LINES BUFFER 
          SA1    CGOA 
          BX0    X1          CODE = LDC 0   LJM RNI   AOD P 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE CODE IN MODULE BUFFER 
          EQ     COM10       RETURN TO COMPILER 
  
  
 CGOW     VFD    42/0,12/77B,6/0                 CONTROL WORD FOR W 
 CGOX     VFD    57/0,3/REG1                     CONTROL WORD FOR X 
 CGOOP    VFD    36/0,6/KEY3,18/0                CONTROL WORD FOR OP
 CGOY     VFD    21/0,6/17B,15/0,12/7777B,3/BUF2,3/REG2  Y CONTROL WORD 
 CGOCOND  VFD    36/0,6/KEY5,18/0                CONTROL WORD FOR COND
 CGOZ     VFD    21/0,6/17B,15/0,12/7777B,3/BUF2,3/REG2  Z CONTROL WORD 
 CGOA     VFD    12/0,12/LDC,12/0,12/LJM,12/RNI 
 CGOSN    DATA   0           BUFFER FOR STATEMENT NUMBER
 CGOXX    DATA   0           BUFFER FOR X 
          EJECT 
 CHALT    TITLE  CHALT - PROCESS THE HALT STATEMENT.
**        CHALT - PROCESS THE HALT STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CHALT - COMPILE PPU CODE FOR THE HALT STATEMENT.  LEGAL 
*         FORMAT FOR THIS STATEMENT IS AS FOLLOWS;
* 
*           HALT
* 
*         ENTRY  CRKBUF = WORD STRING OF SOURCE STATEMENT.
* 
*         EXIT   MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE. 
*                FCERR COMPILER ERROR FLAG SET IF COMPILER ERR CREATED. 
* 
*         ROUTINES CALLED -  CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USE  -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1
*                X - 0, 1 
* 
  
 CHALT    NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          SA1    CHAA 
          BX0    X1          CODE = LDN 0  RJM HALT 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10
  
 CHAA     VFD    24/0,12/LDN,12/RJM,12/HALT 
          EJECT 
 CIF      TITLE  CIF - PROCESS THE IF STATEMENT.
**        CIF - PROCESS THE IF STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CIF - COMPILE EXECUTABLE CODE FOR THE IF STATEMENTS.
*               FORMATS ARE;
* 
*             IF(W COND Y)
*             IF(W OP X COND Y) 
*                                  FOLLOWED BY ANY STATEMENT
*                                  EXCEPT -IF-
* 
*         VALUES FOR THE PARAMETERS ABOVE ARE AS FOLLOWS; 
* 
*              W/X/Y        OP          COND
*              -----       ----        ------ 
*               OB          +            EQ 
*               IB          -            NE 
*               SB         AND           LT 
*            ANY REG.       OR           GT 
*            ANYLEGAL       XOR          LE 
*            CONSTANT.      RS           GE 
*                           LS
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF CURRENT STATEMENT 
*           X0 = 0. 
* 
*         EXIT
* 
*           . MODULE BUFFER CONTAINS THE BINARY CODE GENERATED BY THIS
*             STATEMENT.
*           . FCERR COMPILER ERROR FLAG IS SET IF THIS STATEMENT
*             CREATED A COMPILER ERROR. 
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CLOAD  - GEN. LOAD INSTRUCTIONS. 
*                            CSTOREB- STORE GENERATED CODE. 
*                            FINDOCT- FIND OCTAL VALUE. 
*                            CPLUS  - GEN. PLUS INSTRUCTIONS. 
*                            CMINUS - GEN. SUBTRACT INSTRUCTIONS. 
*                            CAND   - GEN. AND INSTRUCTIONS.
*                            COR.   - GEN. OR INSTRUCTIONS. 
*                            CXOR   - GEN. XOR INSTRUCTIONS.
*                            CRS    - GEN. RS INSTRUCTIONS. 
*                            CLS    - GEN. LS INSTRUCTIONS. 
*                            CEQ    - GEN. EQ INSTRUCTIONS. 
*                            CNE    - GEN. NE INSTRUCTIONS. 
*                            CLT    - GEN. LT INSTRUCTIONS. 
*                            CLE    - GEN. LE INSTRUCTIONS. 
*                            CGE    - GEN. GE INSTRUCTIONS. 
* 
*         DATA AREAS USE -   CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1, 2, 3, 6.
*                X - 0, 1, 2, 3, 6. 
*                B - 5, 6, 7. 
* 
  
 CIF      SX3    X3-1R( 
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT  (
          SX6    B1 
          SA6    ZIF               SET -IF- FLAG
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP CRKBUF POINTER
          SA1    CIFW 
          RJ     FIND        SEARCH FOR W 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          RJ     CLOAD       GENERATE LOAD W CODE 
          SA1    CIFOP
          RJ     FIND        SEARCH FOR OP
          NG     B2,CIF1     IF NOT FOUND 
          SB7    B2          SAVE OP CODE ROUTINE ENTRY IN B7 
          SA1    CIFX 
          RJ     FIND        SEARCH FOR X 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SB6    CIF1        RETURN ADDRESS 
          JP     B7          ENTER OP ROUTINE TO GENERATE OP X CODE 
  
 CIF1     RJ     CSTOREB     SAVE CODE GENERATED IN MODULE BUFFER 
          SA1    CIFCOND
          RJ     FIND        SEARCH FOR COND
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SX6    B2 
          SA6    CIFCCA      SAVE COND CODE ENTRY ADDRESS 
          SA1    CIFX 
          RJ     FIND        SEARCH FOR Y 
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SX3    X3-1R) 
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT ) 
          SB6    CIF2        RETURN ADDRESS 
          EQ     CMINUS      GENERATE MINUS Y CODE
  
 CIF2     MX7    0
          SA1    CIFCCA      COND CODE ENTRY ADDRESS
          SB6    CIF5        RETURN ADDRESS 
          SB5    X1 
          JP     B5          ENTER COND ROUTINE 
  
 CIF5     MX6    48 
          BX4    -X6*X0            EXTRACT JUMP CODE
          LX0    48 
          LX6    48 
          BX0    X0*X6
          RJ     CSTOREB           STORE CODE 
          SA1    PSTORE 
          SA2    MODULE+4 
          MX3    48 
          LX2    24 
          BX2    -X3*X2 
          SX2    X2+MODULE
          MX3    36 
          BX1    -X3*X1            GET SHIFT AND ADDRESS OF NEXT BINARY 
          IX1    X1-X2             MAKE ADDRESS RELATIVE
          MX3    42 
          BX2    -X3*X1            EXTRACT ADDRESS
          BX1    X3*X1             EXTRACT SHIFT
          SX2    X2+B1
          LX2    30                POSITION ADDRESS 
          LX1    18                POSITION SHIFT 
          BX6    X1+X2
          SA1    PLINES 
          SA6    X1                STORE IN LINES BUFFER TO JUMP
          BX0    X4 
          RJ     CSTOREB           STORE JUMP CODE
          SA1    PCRK 
          SA3    X1+B1             GET NEXT CRACKED WORD
          SX6    A3 
          SA6    A1                BUMP CRKBUF POINTER BY 1 
          ZR     X3,COM30          ERROR IF END OF STATEMENT
          SA2    DIF
          BX2    X3-X2
          ZR     X2,COM30          ERROR IF -IF-
          SA2    DEND        DISPLAY CODE END                            MAL049G
          BX2    X3-X2                                                   MAL049G
          ZR     X2,COM30    ERROR IF -END- ON IF COMMAND                MAL049G
          SA1    COMB+1 
          RJ     FIND              FIND PROCESSOR FOR REST OF STATEMENT 
          PL     B2,COM17B         IF NEXT PROCESSOR FOUND
          EQ     COM8              ELSE LOOK FOR END
  
 CIFW     VFD    21/0,6/17B,15/0,12/7777B,3/BUF2,3/REG3  W CONTROL WORD 
 CIFX     VFD    21/0,6/17B,15/0,12/7777B,3/BUF2,3/REG2  X,Y CONT. WORD 
 CIFOP    VFD    36/0,6/KEY4,18/0              CONTROL WORD FOR OP
 CIFCOND  VFD    36/0,6/KEY5,18/0        CONTROL WORD FOR COND
 CIFA     VFD    42/0,12/77B,6/0               CONTROL WORD FOR A 
 CIFB     VFD    42/0,12/3777B,6/0             CONTROL WORD FOR B 
 CIFZ     VFD    42/0,12/77B,6/0               CONTROL WORD FOR Z 
 CIFCCA   DATA   0           BUFFER FOR COND ENTRY ADDRESS
 RJMERR   VFD    36/0,12/RJM,12/ERROR 
          EJECT 
 CLOG     TITLE  CLOG - PROCESS THE LOG STATEMENT.
**        CLOG - PROCESS THE LOG STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CLOG - COMPILE THE LOG STATEMENT.  FORMAT OF THE STATEMENT AS 
*         FOLLOWS;
* 
*                LOG Z
* 
*                             Z 
*                            ---
*                             OB
* 
*         ENTRY  (X3) = DISPLAY CODE VALUE FOR Y. 
* 
*         EXIT
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CLOADC - GEN. LOAD CONST. INSTRUCTIONS 
*                            CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1. 
*                X - 0, 1 
*                B - NONE.
* 
  
 CLOG     ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SA1    CLOGC
          BX0    X1 
          RJ     CABSPPU     RELEASE THE CHANNEL
          RJ     CSTOREB
          SA1    CLOGA
          RJ     FIND        GET Y
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          RJ     CLOADC      GENERATE LOAD CONSTANT CODE
          SA1    CLOGB
          BX0    X1 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       EXIT TO COMSILER 
  
 CLOGA    VFD    54/0,3/BUF6,3/0
 CLOGB    VFD    36/0,12/RJM,12/LOG 
 CLOGC    VFD    24/0,12/LCN,12/RJM,12/POVL 
          EJECT 
 CMSG     TITLE  CMSG - PROCESS THE MSG STATEMENT.
**        CMSG - PROCESS THE MSG STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CMSG - COMPILE PPU CODE FOR THE MSG STATEMENT.
*         FORMATS FOR THIS STATEMENT IS AS FOLLOWS; 
* 
*                MSG W TO LINE Z
*                MSG W(A,B,C,D,E,F,G,H) TO LINE Z 
*                MSG W, X WORDS FROM Y TO LINE Z
*                MSG W TO K 
*                MSG W(A,B,C,D,E,F,G,H) TO K
*                MSG W, X WORDS FROM Y TO K 
* 
* 
*  V            W            X             A-H    Y    Z            K 
* ---          ---          ---            ---   ---  ---          ---
* 0-47 (OCTAL) 0-77 (OCTAL) 1-10 (OCTAL) ANY REG. OB 0-47 (OCTAL) PRINT 
*              ANY REG.     ANY REG.        OB    IB  ANY REG.  DISPLAY 
*                                           IB    SB            DAYFILE 
*                                           SB    ANY REG.
*                                       ANY LEGAL 
*                                       CONSTANT. 
* 
* 
*         K MAY BE ANY COMBINATION OF THE KEYWORDS SPECIFIED. 
* 
*         ENTRY  CRKBUF = WORD STRING OF SOURCE STATEMENT.
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
*                            CMSA  - PPU CODE FOR RJM PMSG. 
* 
*         USES   A - 1. 
*                X - 1. 
*                B - NONE.
* 
  
 CMSG     ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SA1    CHAW 
          RJ     FIND        GET W
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          RJ     CLOAD       GENERATE BINARY FOR LOAD                    MAL046G
          NZ     B3,CMS1     IF REGISTER IS DEFINED 
          SA1    X2+CSN 
          SX6    MSG20
          PL     X1,COM31    ERROR EXIT IF NOT A FORMAT STATEMENT NO. 
          IFEQ   CMSE,0 
          SA3    A3-B1
          MX1    1
          LX1    18 
          BX3    X1+X3             FLAG REFERENCE NOT FOR GLOBAL MAP
          RJ     CXREF             SAVE FORMAT REF
          SA3    A3+B1
          ENDIF 
 CMS1     SX1    STD+PA-6 
          LX0    12 
          BX0    X0+X1
          RJ     CSTOREB     SAVE GENERATED CODE
          ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SX1    X3-1R( 
          SB7    B0          CLEAR NUMBER OF SUBSTITUTIONS
          ZR     X1,CMS7     IF MICRO SUBSTITUTIONS DEFINED 
          SA1    CHAX 
          RJ     FIND        GET X
          NG     B2,CMS4     IF NOT FOUND 
          RJ     CLOAD       GENERATE LOAD X CODE 
          SA1    CHAXX
          BX0    X1 
          RJ     CSTOREB     SAVE CODE GENERATED
          SA1    DWORDS 
          SA2    DFROM
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT WORDS 
          SA3    A3+B1
          BX2    X2-X3
          NZ     X2,COM30    ERROR EXIT IF NEXT ITEM IS NOT FROM
          SX6    A3+B1
          SA6    PCRK        BUMP POINTER TO CRKBUF BY 2
          SA1    CHAY 
          RJ     FIND        GET Y
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SX1    B2-2 
          NZ     X1,CMS2     IF NOT A REGISTER
          SX0    LDN+B3 
          SX1    B3-77B                                                  MAL006G
          NG     X1,CMS3     IF ADDRESS IS DIRECT CELL                   MAL006G
          SX0    LDC                                                     MAL006G
          SX1    B3                                                      MAL006G
          LX0    12                                                      MAL006G
          BX0    X0+X1       FORM LDC ADDRESS                            MAL006G
          EQ     CMS3 
  
 CMS2     RJ     CLOADC      GENERATE LOAD CONSTANT CODE
 CMS3     LX0    12 
          SX1    STD+PA-2    CODE = LOAD CONSTANT Y   STD PA-2
          EQ     CMS5        GO SAVE GENERATED CODE 
  
 CMS4     SX0    LDN+B7 
          SX1    STD+PA-5 
          LX0    12 
          BX0    X0+X1
          SX1    STD+PA-7    SET DEFAULT CODE 
          LX0    12 
          ZR     B7,CMS5     IF NO SUBSTITUTIONS
          SA1    CHAC 
          LX0    12 
 CMS5     BX0    X0+X1
          RJ     CSTOREB     SAVE GENERATED CODE
          SA1    DTO         CONTINUE PROCESSING MSG STATEMENT
          SA2    DLINE
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT TO
          SA3    A3+B1
          BX2    X3-X2
          NZ     X2,CMS11    IF NEXT ITEM IS NOT LINE 
          SX6    A3+B1
          SA6    PCRK        BUMP POINTER TO CRKBUF BY 2
          SA1    CHAZ 
          RJ     FIND        GET Z
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          RJ     CLOAD       GENERATE LOAD Z CODE 
          ZR     X3,CMS6           IF END OF STATEMENT
          SA2    DPLUS
          BX2    X3-X2
          NZ     X2,COM30          IF NEXT ITEM IS NOT +
          SA3    PCRK 
          SX6    X3+B1
          SA6    A3                BUFP POINTER TO CRKBUF BY 1
          SA1    CHAZZ
          RJ     FIND              GET OCTAL VALUE
          NG     B2,COM31          ERROR EXIT IF NOT FOUND
          SB6    CMS5A
          EQ     CADD              GENERATE CODE FOR ADD VALUE
 CMS5A    NZ     X3,COM30          ERROR EXIT IF NOT END OF STATEMENT 
 CMS6     SA1    CMSA 
          LX0    24 
          BX0    X1+X0
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE JUMP CODE 
          EQ     COM10       EXIT TO COMPILER 
  
 CMS7     SX6    A3+B1
          SA6    PCRK        BUMP POINTER TO CRKBUF 
          SA3    A3+B1       NEXT ITEM FROM CRKBUF
 CMS8     SX1    X3-2R**
          NZ     X1,CMS8J    IF NOT START OF LITERAL
          SA3    A3+B1       GET LITERAL DATA 
 CMS8B    MX1    12 
          BX2    X3*X1       GET 2 CHARACTERS 
          ZR     X2,CMS8G    IF EMPTY 
          BX3    X3-X2
          LX3    12          REMOVE 2 CHARACTERS
          LX2    12 
          MX5    -6 
          BX5    -X5*X2 
          NZ     X5,CMS8C    IF LOWER CHARACTER NOT ZERO
          SX2    X2+1R       ADD BLANK
 CMS8C    SB2    3
          RJ     CLOADC      GENERATE LOAD CONSTANT CODE
          SA1    MODULE+5    GET 16BIT FLAG 
          LX1    59-12
          PL     X1,CMS8D    IF NOT 16-BIT MALET
          SB6    B7-3 
          EQ     CMS8E
 CMS8D    SB6    B7-4 
          NG     B6,CMS8E    IF LESS THAN PA+3
          SB6    B6+B1       SKIP PA+3
 CMS8E    SX0    B6+STD+PA+3
          RJ     CSTOREB     SAVE GENERATED CODE
          SB7    B7+B1       BUMP NUMBER OF PARAMETERS
          EQ     CMS8B       UNPACK REST OF LITERAL 
  
 CMS8G    SA3    A3+B1       NEXT ITEM FROM CRKBUF
          SX1    X3-2R**
          ZR     X3,COM30    IF END OF STATEMENT
          NZ     X1,CMS8B    IF NOT END OF LITERAL
          SA3    A3+B1       NEXT ITEM FROM CRKBUF
          SX6    A3 
          SA6    PCRK        UPDATE POINTER TO CRKBUF 
          EQ     CMS9A
  
 CMS8J    SA1    CHAB 
          RJ     FIND        GET A-H
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          RJ     CLOAD       GENERATE LOAD A-H CODE 
          SA1    MODULE+5    GET 16BIT FLAG 
          LX1    59-12
          PL     X1,CMS8K    IF NOT 16-BIT MALET
          SB6    B7-3 
          EQ     CMS9 
 CMS8K    SB6    B7-4 
          NG     B6,CMS9     IF LESS THAN PA+3
          SB6    B6+B1       SKIP PA+3
 CMS9     SX0    B6+STD+PA+3
          RJ     CSTOREB     SAVE GENERATED CODE
          SB7    B7+B1       BUMP NUMBER OF PARAMETERS
 CMS9A    SX1    X3-1R) 
          NZ     X1,CMS8     IF NOT END OF PARAMETERS 
          SB6    10B
          GT     B7,B6,COM30  IF TOO MANY PARAMETERS
          SA3    A3+B1
          SX6    A3 
          SA6    PCRK        BUMP POINTER TO CRKBUF 
          EQ     CMS4        GO DECODE Z
  
 CMS11    SX0    LDN+50B     SET STARTING VAULE FOR AA CODE 
          SA1    DDISPLAY 
          SA2    DDAYFIL
          SA4    DPRINT 
 CMS12    BX5    X1-X3
          SX6    4
          ZR     X5,CMS13    IF DISPLAY 
          BX5    X2-X3
          SX6    2
          ZR     X5,CMS13    IF DAYFILE 
          BX5    X4-X3
          SX6    B1 
          NZ     X5,COM30    ERROR EXIT IF NOT PRINT
 CMS13    BX0    X0+X6       ADD BIT TO CODE
          SA3    A3+B1       NEXT ITEM FROM CRKBUF
          NZ     X3,CMS12    IF NOT END OF STATEMENT
          EQ     CMS6        GO SAVE CODE AND EXIT
  
 CHAB     VFD    21/0,6/17B,15/0,12/7777B,3/BUF2,3/REG2   CW FOR A-H
 CHAC     VFD    36/0,12/LDN,12/STD+PA-7
 CHAD     VFD    24/0,12/LDN,12/STD+PA-5,12/STD+PA-7
 CHAW     VFD    42/0,12/77B,3/0,3/REG2           CW FOR W
 CHAX     VFD    42/0,12/10B,3/0,3/REG2           CW FOR X
 CHAY     VFD    54/0,3/BUF2,3/REG2               CW FOR Y
 CHAZ     VFD    42/0,12/47B,3/0,3/REG2           CW FOR Z
 CHAZZ    VFD    42/0,12/47B,6/0   CW FOR Z ADDITIVE VALUE
 CHAXX    VFD    36/0,12/STD+PA-5,12/STD+PA-7 
 CMSA     VFD    36/0,12/RJM,12/PMSG
          EJECT 
 CPASS    TITLE  CPASS  - PROCESS THE PASS STATEMENT. 
**        CPASS  - COMPILE  THE PASS STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CPASS  - COMPILE  THE PASS STATEMENT.  THE
*         FORMAT OF THIS STATEMENT IS AS FOLLOWS; 
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - NONE.
*                X - 0. 
*                B - NONE.
* 
  
 CPASS    NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          EQ     COM10       EXIT TO COMPILER 
          EJECT 
 CPAUSE   TITLE  CPAUSE - PROCESS THE PAUSE STATEMENT.
**        CPAUSE - COMPILE  THE PAUSE STATEMENT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CPAUSE - COMPILE  THE PAUSE STATEMENT.  THE 
*         FORMAT OF THIS STATEMENT IS AS FOLLOWS; 
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1. 
*                X - 0, 1 
* 
  
 CPAUSE   NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          SA1    CPAU 
          BX0    X1 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       EXIT TO COMPILER 
  
 CPAU     VFD    24/0,12/LDN+1,12/RJM,12/HALT 
          EJECT 
 CPICTUR  TITLE  CPICTUR - PROCESS THE PICTURE STATEMENT. 
**        CPICTUR - PROCESS THE PICTURE STATEMENT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CPICTUR - PROCESS THE PICTURE STATEMENT.  FORMATS OF
*         THIS STATEMENT IS AS FOLLOWS; 
* 
*           PICTURE 
*           PICTURE AND BLANK 
*           PICTURE AND BLANK PLOT
*           PICTURE AND BLANK DISPLAY 
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1, 2, 3. 
*                X - 0, 1, 2, 3.
*                B - NONE.
* 
  
 CPICTUR  SX0    LDN         DEFAULT CODE TO LDN 0
          ZR     X3,CPI2     IF END OF STATEMENT
          SA1    DAND 
          SA2    DBLANK 
          BX1    X3-X1
          NZ     X1,COM30    ERROR EXIT IF NEXT ITEM IS NOT AND 
          SA3    A3+B1
          BX2    X3-X2
          NZ     X2,COM30    ERROR EXIT IF NEXT ITEM IS NOT BLANK 
          SX0    LDN+3       SET CODE FOR BLANK 
          SA3    A3+B1
          ZR     X3,CPI2     IF END OF STATEMENT
          SX0    LDN+1       SET CODE FOR BLANK PLOT
          SA1    DPLOT
          SA2    DDISPLAY 
          BX1    X1-X3
          ZR     X1,CPI1     IF BLANK PLOT
          SX0    X0+B1       SET CODE FOR BLANK DISPLAY 
          BX2    X2-X3
          NZ     X2,COM30    ERROR EXIT IF NOT BLANK PLOT OR DISPLAY
 CPI1     SA3    A3+B1
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
 CPI2     LX0    24 
          SA1    CPIA 
          BX0    X1+X0
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE CODE GENERATED
          EQ     COM10       EXIT TO COMPILER 
  
 CPIA     VFD    36/0,12/RJM,12/PPICTUR 
          EJECT 
 CPLOT    TITLE  CPLOT - PROCESS THE PLOT STATEMENT.
**        CPLOT - PROCESS THE PLOT STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CPLOT  - COMPILE PPU CODE FOR THE PLOT  STATEMENT.  THE 
*         FORMAT OF THIS STATEMENT IS AS FOLLOWS; 
* 
*                PLOT LINE X CHAR Y 
* 
*                   X            Y
*                  ---          --- 
*                 0-47 (OCTAL) 0-73 (OCTAL) 
*                 ANY REG.     ANY REG. 
* 
* 
*         **ILLEGAL WHEN KEYWORD 16BIT IS PRESENT IN THE MODULE CARD. 
* 
*         ENTRY     CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CLOAD  - GEN. LOAD INSTRUCTIONS. 
*                            CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
*                            PCRK  - POINTER TO CRACK BUFFER
* 
*         USES   A - 1, 6.
*                X - 0, 1, 3, 6.
*                B - NONE.
* 
  
 CPLOT    SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,COM30    IF 16 BIT SET ERROR
          SA1    DLINE
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT LINE
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          SA1    CPLX 
          RJ     FIND        GET X
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SA1    DCHAR
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT CHAR
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          RJ     CLOAD       GENERATE LOAD X CODE 
          SX0    STD+PA 
          SA1    CPLY 
          RJ     FIND        GET Y
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          RJ     CLOAD       GENERATE LOAD Y CODE 
          SA1    CPLA 
          BX0    X1 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       EXIT TO COMPILER 
  
 CPLX     VFD    42/0,12/47B,3/0,3/REG2    CONTROL WORD FOR X 
 CPLY     VFD    42/0,12/73B,3/0,3/REG2    CONTROL WORD FOR Y 
 CPLA     VFD    36/0,12/RJM,12/PLOT
          EJECT 
 CRANDOM  TITLE  CRANDOM - PROCESS THE RANDOM STATEMENT.
**        CRANDOM - PROCESS THE RANDOM STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CRANDOM -COMPILE THE RANDOM STATEMENT. FORMATS OF THIS
*         STATEMENT ARE AS FOLLOWS; 
* 
*           RANDOM TO X FOR Y 
*           RANDOM TO X FOR Y, START Z
* 
*               X            Y            Z 
*              ---          ---          ---
*              OB      ANY REGISTER       RT
*              IB         1 - 500     ANY REGISTER
*                                      ANY BUFFER 
*                                      ANY LEGAL
*                                      CONSTANT.
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CLOADC - GEN. LOAD CONST. INSTRUCTIONS 
*                            CSTOREB- STORE GENERATED CODE. 
*                            CLOAD  - GEN. LOAD INSTRUCTIONS. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1, 6.
*                X - 0, 1, 3, 6.
*                B - NONE.
* 
  
 CRANDOM  SA1    DTO
          BX3    X1-X3
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT TO
          RJ     CSETP       GENERATE SET P INSTRUCTIONS                 MAL048G
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          SA1    CRAX 
          RJ     FIND        GET X
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          SA1    DFOR 
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT FOR 
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          RJ     CLOADC      GENERATE LOAD CONSTANT CODE
          SX0    STD+PA 
          SA1    CRAY 
          RJ     FIND        GET Y
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          RJ     CLOAD       GENERATE LOAD Y CODE 
          SX0    STD+PA+1 
          RJ     CSTOREB     SAVE GENERATED CODE
          SX0    LDC+40B     SET DEFAULT CODE FOR Z = LDC 400000B 
          LX0    12 
          ZR     X3,CRA1     IF END OF STATEMENT
          SA1    DSTART 
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT START 
          SA1    PCRK 
          SX6    X1+B1
          SA6    A1          BUMP POINTER TO CRKBUF 
          SA1    CRAZ 
          RJ     FIND        GET Z
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          MX0    0           CLEAR DEFAULT CODE 
          RJ     CLOAD       GENERATE LOAD Z CODE 
 CRA1     SA1    CRAA 
          LX0    24 
          BX0    X0+X1
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       EXIT TO COMPILER 
  
 CRAX     VFD    54/0,3/BUF1,3/0               CONTROL WORD FOR X 
 CRAY     VFD    42/0,12/500B,3/0,3/REG2       CONTROL WORD FOR Y 
 CRAZ     VFD    21/0,6/17B,15/0,12/7777B,3/BUF2,3/REG3   Z CONTROL WORD
 CRAA     VFD    36/0,12/RJM,12/RANDOM
          EJECT 
 CRETURN  TITLE  CRETURN - PROCESS THE RETURN STATEMENT.
**        CRETURN - PROCESS THE RETURN STATEMENT. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CRETURN - COMPILE PPU CODE FOR THE RETURN STATEMENT. THE
*         FORMAT FOR THIS STATEMENT IS AS FOLLOWS;
* 
*         ENTRY 
* 
*           CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1. 
*                X - 0, 1.
*                B - NONE.
* 
  
 CRETURN  NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          SX6    B1 
          SA6    ZXFER             SET TRANSFER FLAG
          RJ     CSETP             GENERATE CODE TO SET P REGISTER
          SA1    CRTA 
          BX0    X1          CODE = RJM RETURN
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       RETURN TO COMPILER 
  
 CRTA     VFD    36/0,12/LJM,12/RETURN
          EJECT 
 CWEQX    TITLE  CWEQX - PROCESS REPLACEMENT STATEMENTS.
**        CWEQX - PROCESS REPLACEMENT STATEMENTS. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CWEQX - COMPILE REPLACEMENT STATEMENTS.  FORMATS ARE; 
* 
*              W = X
*              W = X OP Y 
*              W = X OP Y OP Z
* 
*         VALUES FOR THE PARAMETERS ARE AS FOLLOWS; 
* 
*                 W           X         OP        Y           Z 
*                ---         ---       ----      ---         ---
*              B0-B15      ANY REG.      +     ANY REG.    ANY REG. 
*                WC        ANY BUF.      -     EXCEPT RT   EXCEPT RT
*                BA          RT         AND    ANY BUF.    ANY BUF. 
*                OB        ANY LEGAL    OR     ANY LEGAL   ANY LEGAL
*                IB        CONSTANT.    XOR    CONSTANT.   CONSTANT.
*                                       RS
*                                       LS
* 
*         ENTRY 
* 
*           CRKBUF CONTAINS THE WORD STRING OF THE CRACKED STATEMENT. 
*           X0 = 0. 
* 
*         EXIT
* 
*           EXECUTABLE PPU CODE GENERATED AND STORED INTO THE MODULE
*           BUFFER. 
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CLOAD  - GEN. LOAD INSTRUCTIONS. 
*                            CADD   - GEN. ADD INSTRUCTIONS.
*                            CMINUS - GEN. SUBTRACT INSTRUCTIONS. 
*                            CAND   - GEN. LOGICAL PRODUCT INSTRUCT.
*                            COR    - GEN. INCLUCIVE OR CODE. 
*                            CXOR   - GEN. LOGICAL DIFF INSTRUCTION.
*                            CRS    - GEN. RIGHT SHIFT CODE.
*                            CLF    - GEN. LEFT SHIFT CODE. 
*                            CSTORE - GEN. STORE INSTRUCTIONS.
*                            CSTOREB- STORE GENERATED CODE. 
* 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1, 6, 7. 
*                X - 0, 1, 3, 6, 7. 
*                B - 2, 3, 6, 7.
* 
*           THIS ROUTINE ASSUMES THAT X3 IS NOT CLOBBERED BY
*           CLOAD AND CSTOREB, AND THAT NONE OF THE ROUTINES CALLED 
*           CLOBBER B7. 
* 
  
 CWEQX    MX7    0
          SA7    CRSFLG      CLEAR PASS FLAG
          SA1    CRSW 
          RJ     FIND        FIND W 
          NG     B2,COM31    ERROR EXIT IF NOT A LEGAL W
          SX3    X3-1R= 
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT = 
          SA3    A3+B1       NEXT ITEM FROM CRKBUF
          SX6    A3 
          SA6    PCRK        BUMP POINTER TO CRKBUF 
          ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SX7    B2 
          LX7    18 
          SX1    B3 
          BX7    X7+X1
          LX7    24                                                      MAL050G
          BX7    X7+X2
          SA7    CRSSW       SAVE W ( B2,B3, AND X2)
          NZ     B2,CRS3     IF NOT BUFFER(REGISTER)
          RJ     CSETP             GENERATE CODE TO SET P REGISTER
          SA1    CRSSW
          MX2    -24                                                     MAL050G
          BX2    -X2*X1                                                  MAL050G
          AX1    24                                                      MAL050G
          SB3    X1          RESTORE B3 
          SB2    B0                RESTORE B2 
          RJ     CLOADC      GENERATE LOAD CONSTANT CODE
          SA1    TESTWC 
          BX0    X1 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     STORE GENERATED CODE 
 CRS3     SA1    CRSX 
          RJ     FIND        FIND X 
          NG     B2,COM31    ERROR EXIT IF NOT LEGAL X
          RJ     CLOAD       GENERATE LOAD X CODE 
          ZR     X3,CRS6     IF END OF STATEMENT ( FROM LAST FIND)
 CRS4     SA1    CRSOP
          RJ     FIND        FIND OP
          NG     B2,COM31    ERROR EXIT IF NOT LEGAL OP 
          ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SB7    B2          SAVE OP JUMP PROCESSING ADDRESS
          SA1    CRSYZ
          RJ     FIND        FIND Y OR Z
          NG     B2,COM31    ERROR EXIT IF NOT LEGAL Y OR Z 
          SB6    CRS5        RETURN ADDRESS 
          JP     B7          ENTER OP ROUTINE - RETURN TO CRS3
  
 CRS5     RJ     CSTOREB     SAVE GENERATED CODE INTO MODULE BUFFER 
          ZR     X3,CRS6     IF END OF STATEMENT ( FROM LAST FIND)
          SA1    CRSFLG      PASS FLAG
          SX6    B1 
          NZ     X1,COM30    ERROR EXIT IF PASS 2 
          SA6    CRSFLG      SET PASS FLAG
          EQ     CRS4        REPEAT Y LOOP FOR Z
  
 CRS6     SA1    CRSSW       RESTORE W
          MX2    -24                                                     MAL050G
          BX2    -X2*X1 
          AX1    24                                                      MAL050G
          SB3    X1 
          AX1    18 
          SB2    X1 
          RJ     CSTORE      GENERATE STORE TO W CODE 
          RJ     CSTOREB     SAVE GENERATED CODE INTO MODULE BUFFER 
          EQ     COM10       RETURN TO COMPILER 
  
 CRSFLG   DATA   0           PASS FLAG
 CRSSW    DATA   0           SAVE W BUFFER
 CRSW     VFD    54/0,3/BUF1,3/REG1              CONTROL WORD FOR W 
 CRSX     VFD    21/0,6/17B,15/0,12/7777B,3/BUF2,3/REG3   X CONTROL WORD
 CRSYZ    VFD    21/0,6/17B,15/0,12/7777B,3/BUF2,3/REG2   Y,X CONT WORD 
 CRSOP    VFD    36/0,6/KEY4,18/0                CONTROL WORD FOR OP
 TESTWC   VFD    36/0,12/RJM,12/TESTBI
          EJECT 
 CYSRD    TITLE  CYSRD - PROCESS THE SYSRD STATEMENT. 
**        CYSRD - PROCESS THE SYSRD STATEMENT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CYSRD - COMPILE PPU CODE FOR THE SYSRD STATEMENT. 
*         THE  FORMAT FOR THIS STATEMENT IS AS FOLLOWS; 
* 
*                 SYSRD, STATUS TO Z
*                *SYSRD ESM STATUS TO Z 
*                *SYSRD CM STATUS TO Z
*               **SYSRD DMA STATUS TO Z 
* 
*         Z CAN BE REGISTERS B0-B7, WC OR BA. 
* 
*         * ILLEGAL WHEN KEYWORD 16BIT IS PRESENT IN THE MODULE CARD. 
*         **ILLEGAL WHEN KEYWORD 16BIT IS NOT PRESENT IN THE MODULE CARD. 
* 
*         ENTRY    CRKBUF = WORD STRING OF SOURCE STATEMENT.
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  FIND   - FIND THE NEXT ITEM FROM SOURCE. 
*                            CLOAD  - GEN. LOAD INSTRUCTIONS. 
*                            CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1, 3, 6. 
*                X - 0, 1, 3, 6.
*                B - NONE.
* 
  
 CYSRD    ZR     X3,COM30    ERROR EXIT IF END OF STATEMENT 
          SA1    DSTATUS
          BX1    X1-X3
          ZR     X1,CRD1     IF DISPLAY CODE STATUS 
          SA1    FCMSE
          ZR     X1,CRD0     OK IF NOT CMSE 
          SX6    MSG18       UNRECOGNIZED STATEMENT 
          EQ     COM31
  
 CRD0     SA1    F16BIT      16-BIT FLAG
          ZR     X1,CRD0A    IF NOT 16-BIT
          SA1    DESM 
          BX1    X1-X3
          ZR     X1,COM30    ERROR IF ESM AND 16BIT 
          SA1    DCM
          BX1    X1-X3
          ZR     X1,COM30    ERROR IF CM AND 16BIT
          SA1    DDMA 
          BX1    X1-X3
          ZR     X1,CRD0C    IF DMA AND 16BIT 
          SX6    MSG18       UNRECOGNIZED STATEMENT 
          EQ     COM31
  
 CRD0A    SA1    DESM 
          BX1    X1-X3
          NZ     X1,CRD0B    IF NOT ESM 
          SA1    DSTATUS
          SA3    A3+B1
          BX1    X1-X3
          NZ     X1,COM30    ERROR IF NOT STATUS
          SA3    A3+B1
          SA1    DTO
          BX1    X1-X3
          NZ     X1,COM30    ERROR IF NOT TO
          SA3    A3+B1
          SX6    A3 
          SA6    PCRK        UPDATE POINTER TO CRKBUF 
          SA1    CRDZ 
          RJ     FIND 
          NG     B2,COM31    ERROR EXIT IT NOT FOUND
          LX0    12 
          SX7    LDN+B3 
          BX0    X0+X7
          LX0    48 
          SA1    CRDB 
          EQ     CRD2 
 CRD0B    SA1    DCM
          BX1    X1-X3
          NZ     X1,COM30    IF NOT CM
          SA1    DSTATUS
          SA3    A3+B1
          BX1    X1-X3
          NZ     X1,COM30    ERROR IF NOT STATUS
          SA3    A3+B1
          SA1    DTO
          BX1    X1-X3
          NZ     X1,COM30    ERROR IF NOT TO
          SA3    A3+B1
          SX6    A3 
          SA6    PCRK        UPDATE POINTER TO CRKBUF 
          SA1    CRDZ 
          RJ     FIND 
          NG     B2,COM31    ERROR EXIT IT NOT FOUND
          LX0    12 
          SX7    LDN+B3 
          BX0    X0+X7
          LX0    48 
          SA1    CRDC 
          EQ     CRD2 
  
 CRD0C    SA1    DDMA 
          BX1    X1-X3
          NZ     X1,COM30    IF NOT DMA 
          SA1    DSTATUS
          SA3    A3+B1
          BX1    X1-X3
          NZ     X1,COM30    ERROR IF NOT STATUS
          SA3    A3+B1
          SA1    DTO
          BX1    X1-X3
          NZ     X1,COM30    ERROR IF NOT TO
          SA3    A3+B1
          SX6    A3 
          SA6    PCRK        UPDATE POINTER TO CRKBUF 
          SA1    CRDZ 
          RJ     FIND 
          NG     B2,COM31    ERROR EXIT IT NOT FOUND
          LX0    12 
          SX7    LDN+B3 
          BX0    X0+X7
          LX0    48 
          SA1    CRDD 
          EQ     CRD2 
  
  
 CRD1     SA3    A3+B1
          SA1    DTO
          BX3    X3-X1
          NZ     X3,COM30    ERROR EXIT IF NEXT ITEM IS NOT TO
          SX6    A3+B1
          SA6    PCRK        BUMP POINTER TO CRKBUF BY 2
          SA1    CRDZ 
          RJ     FIND        GET Z
          NG     B2,COM31    ERROR EXIT IF NOT FOUND
          LX0    12 
          SX7    LDN+B3 
          BX0    X0+X7
          LX0    48 
          SA1    CRDA 
 CRD2     NZ     X3,COM30    ERROR IF NOT END OF STATEMENT
          BX0    X0+X1
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       EXIT TO COMPILER 
  
 CRDA     VFD    12/0,12/STD+PA,12/LDN+2,12/RJM,12/SYS
 CRDB     VFD    12/0,12/STD+PA,12/LDN+0,12/RJM,12/SYS
 CRDC     VFD    12/0,12/STD+PA,12/LDN+7,12/RJM,12/SYS
 CRDD     VFD    12/0,12/STD+PA,12/LDN+12B,12/RJM,12/SYS
 DESM     VFD    60/3LESM 
 DCM      VFD    60/2LCM
 DDMA     VFD    60/3LDMA 
 CRDZ     VFD    57/0,3/REG1 CW FOR Z 
          EJECT 
 CYSREW   TITLE  CYSREW - PROCESS THE SYSREW STATEMENT. 
**        CYSREW - PROCESS THE SYSREW STATEMENT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CYSREW - COMPILE PPU CODE FOR THE SYSREW STATEMENT. 
*         THE FORMAT OF THIS STATEMENT IS AS FOLLOWS; 
* 
*                SYSREW 
*               *SYSREW ESM 
*               *SYSREW CM
*               **SYSREW DMA
* 
*         ENTRY   CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         * ILLEGAL WHEN KEYWORD 16BIT IS PRESENT IN THE MODULE CARD. 
*         **ILLEGAL WHEN KEYWORD 16BIT IS NOT PRESENT IN THE MODULE CARD. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1. 
*                X - 0, 1 
*                B - NONE.
* 
  
 CYSREW   SA1    CRWA 
          BX0    X1 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CRW      IF NOT 16-BIT
          SA1    DESM 
          BX1    X1-X3
          ZR     X1,CRW0A    IF ESM 
          SA1    DCM
          BX1    X1-X3
          ZR     X1,CRW0A    IF CM
          SA1    DDMA 
          BX1    X1-X3
          ZR     X1,CRW1A    IF DMA 
 CRW0A    EQ     COM30       ERROR IF ESM OR CM AND 16BIT 
  
  
 CRW      SA1    DESM 
          BX1    X1-X3
          ZR     X1,CRW0B    IF ESM 
          SA1    DCM
          BX1    X1-X3
          NZ     X1,CRW1     IF NOT CM
          EQ     CRW2        IF CM
 CRW0B    SA1    FCMSE
          ZR     X1,CRW0     OK IF NOT CMSE 
          SX6    MSG18       UNRECOGNIZED STATEMENT 
          EQ     COM31
  
 CRW0     SA3    A3+B1
          SX6    A3 
          SA6    PCRK        UPDATE POINTER TO PCRK 
          SA1    CRWB 
          BX0    X1 
  
 CRW1     NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          RJ     CABSPPU     ABSOLUTIZE PP ADDRESS
          RJ     CSTOREB     CODE = LDN 3   RJM SYS 
          EQ     COM10       EXIT TO COMPILER 
  
 CRW1A    SA3    A3+B1
          SX6    A3 
          SA6    PCRK        UPDATE POINTER TO PCRK 
          SA1    CRWD 
          BX0    X1 
          EQ     CRW1 
  
  
 CRW2     SA1    FCMSE
          ZR     X1,CRW3     OK IF NOT CMSE 
          SX6    MSG18       UNRECOGNIZED STATEMENT 
          EQ     COM31
  
 CRW3     SA3    A3+B1
          SX6    A3 
          SA6    PCRK        UPDATE POINTER TO PCRK 
          SA1    CRWC 
          BX0    X1 
          EQ     CRW1 
  
 CRWA     VFD    24/0,12/LDN+3,12/RJM,12/SYS
 CRWB     VFD    24/0,12/LDN+5,12/RJM,12/SYS
 CRWC     VFD    24/0,12/LDN+10B,12/RJM,12/SYS
 CRWD     VFD    24/0,12/LDN+13B,12/RJM,12/SYS
          EJECT 
 CYSWR    TITLE  CYSWR - PROCESS THE SYSWR STATEMENT. 
**        CYSWR - PROCESS THE SYSWR STATEMENT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CYSWR - COMPILE PPU CODE FOR THE SYSWR STATEMENT. 
*         THE FORMAT OF THIS STATEMENT IS AS FOLLOWS; 
* 
*                SYSWR
*               *SYSWR ESM
*               *SYSWR CM 
*              **SYSWR DMA
* 
*         ENTRY   CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         * ILLEGAL WHEN KEYWORD 16BIT IS PRESENT IN THE MODULE CARD. 
*         **ILLEGAL WHEN KEYWORD 16BIT IS NOT PRESENT IN THE MODULE CARD. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  CSTOREB- STORE GENERATED CODE. 
* 
*         DATA AREAS USED -  CRKBUF- WORD STRING OF SOURCE STATEMENT. 
*                            MODULE- CONTAINS BINARY CODE GENERATED.
* 
*         USES   A - 1. 
*                X - 0, 1.
*                B - NONE.
* 
  
 CYSWR    SA1    CWRA 
          BX0    X1 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CWR      IF NOT 16-BIT
          SA1    DESM 
          BX1    X1-X3
          ZR     X1,CWR0A    IF ESM 
          SA1    DCM
          BX1    X1-X3
          ZR     X1,CWR0A    IF CM
          SA1    DDMA 
          BX1    X1-X3
          ZR     X1,CWR1A    IF DMA 
 CWR0A    EQ     COM30       ERROR IF ESM OR CM AND 16BIT 
  
  
 CWR      SA1    DESM 
          BX1    X1-X3
          ZR     X1,CWR0B    IF ESM 
          SA1    DCM
          BX1    X1-X3
          NZ     X1,CWR1     IF NOT CM
          EQ     CWR2        IF CM
 CWR0B    SA1    FCMSE
          ZR     X1,CWR0     OK IF NOT CMSE 
          SX6    MSG18       UNRECOGNIZED STATEMENT 
          EQ     COM31
  
 CWR0     SA3    A3+B1
          SX6    A3 
          SA6    PCRK        UPDATE POINTER TO CRKBUF 
          SA1    CWRB 
          BX0    X1 
  
 CWR1     NZ     X3,COM30    ERROR EXIT IF NOT END OF STATEMENT 
          RJ     CABSPPU     ABSOLUTIZE PP ADDRESS
          RJ     CSTOREB     SAVE GENERATED CODE
          EQ     COM10       EXIT TO COMPILER 
  
 CWR1A    SA3    A3+B1
          SX6    A3 
          SA6    PCRK        UPDATE POINTER TO CRKBUF 
          SA1    CWRD 
          BX0    X1 
          EQ     CWR1 
  
 CWR2     SA1    FCMSE
          ZR     X1,CWR3     OK IF NOT CMSE 
          SX6    MSG18       UNRECOGNIZED STATEMENT 
          EQ     COM31
  
 CWR3     SA3    A3+B1
          SX6    A3 
          SA6    PCRK        UPDATE POINTER TO CRKBUF 
          SA1    CWRC 
          BX0    X1 
          EQ     CWR1 
 CWRA     VFD    24/0,12/LDN+4,12/RJM,12/SYS
 CWRB     VFD    24/0,12/LDN+1,12/RJM,12/SYS
 CWRC     VFD    24/0,12/LDN+6,12/RJM,12/SYS
 CWRD     VFD    24/0,12/LDN+14B,12/RJM,12/SYS
          EJECT 
 CGETS    TITLE  CGETS - GET SOURCE CODE. 
**        CGETS - GET SOURCE CODE.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CGETS - GET SOURCE CODE.
* 
*         ENTRY  .
* 
*         EXIT
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  CLINE   - PRINT LINE BUFFER. 
*                            LINES   - LINES BUFFER.
*                            PSOURCE - POINTER INTO SOURCE BUFFER.
*                            BLANKS  - WORD CONTAINING 10 BLANKS. 
*                            CGETSA  - WORD CONTAINING 7 BLANKS.
* 
*         USES   A - 1, 2, 6. 
*                X - 1, 2, 3, 6.
*                B - 2. 
  
 CGETS    DATA   0           ENTRY/EXIT 
          SB2    LINES
          SX1    B7-B2             LINE NUMBER
          MX2    -3 
          SB2    B1+B1
          SX3    3R000
 CGETS1   BX6    -X2*X1 
          IX3    X3+X6
          LX2    6
          LX1    3
          SB2    B2-B1
          PL     B2,CGETS1
          SA1    CGETSA 
          BX6    X1+X3
          LX6    18 
          SA6    CLINE
          SA1    PSOURCE
          SA2    X1 
          SB2    6
 CGETS2   BX6    X2          MOVE SOURCE CODE TO CLINE
          SA6    A6+B1
          SB2    B2-B1
          SA2    A2+B1
          NZ     B2,CGETS2   IF ALL WORDS NOT MOVED 
          SB2    6
          SA2    BLANKS 
          BX6    X2 
 CGETS3   SA6    A6+B1       BLANK FILL REST OF LINE
          SB2    B2-B1
          NZ     B2,CGETS3   IF ALL WORDS NOT BLANKED 
          MX6    0
          SA6    A6+B1       ZERO LAST WORD 
          SX6    X1+6 
          SA6    A1          BUMP PSOURCE 
          EQ     CGETS       EXIT 
  
 CGETSA   VFD    42/7L       ,18/0
          EJECT 
 CLIST    TITLE  CLIST - PROCESS THE LIST PARAMETER.
**        CLIST - PROCESS THE LIST PARAMETER. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CLIST - PROCESS THE LIST PARAMETER ON THE COMPILE CARD. 
* 
*         ENTRY   CRKBUF = WORD STRING OF SOURCE STATEMENT. 
* 
*         EXIT
* 
*           . MODULE = BINARY PPU CODE GENERATED FOR THE SOURCE.
*           . FCERR COMPILER ERROR FLAG SET IF COMPILER ERROR CREATED.
* 
*         ROUTINES CALLED -  PRINT - PRINT LINE TO ACTIVE OUTPUT FILE.
*                            CGETS   - LINE NO. AND SOURCE TO LINE BFR. 
* 
*         DATA AREAS USED -  SOURCE  - SOURCE BUFFER. 
*                            PSOURCE - POINTER INTO SOURCE BUFFER.
*                            LINES   - LINES BUFFER.
*                            PRINTA  - PAGE EJECT DATA. 
*                            FCERR   - ERROR FLAG.
*                            FLIST   - LIST OPTION FLAG.
* 
*         USES   A - 1, 2, 3, 5, 6. 
*                X - 1, 2, 3, 4, 5, 6, 7. 
*                B - 2, 3, 4, 5, 7. 
* 
  
**      STEP 01- INITIALIZE SOURCE POINTER, GET LIST FLAG IF ON OUTPUT
*                PAGE EJECT THEN STEP 2, ELSE STEP 2. 
* 
 CLIST    DATA   0           ENTRY/EXIT 
          SX6    SOURCE 
          SA6    PSOURCE
          MX6    0
          SA6    FCERR       CLEAR COMPILER ERROR FLAG
          SB7    LINES       POINTER TO LINES BUFFER
          SA5    FLIST       GET LIST OPTION FLAG 
          ZR     X5,CLIST1
          IFEQ   CMSE,0,2 
          SX6    CNTMAX 
          SA6    CNTLINE
  
**      STEP 02- TEST FOR ERROR ON THIS SOURCE LINE IF PRESENT THEN 
*                STEP 5, ELSE GO TO STEP 3. 
* 
 CLIST1   SA1    B7          READ ITEM FROM LINE BUFFER 
          SX7    X1 
          NZ     X7,CLIST3   IF ERROR ON THIS LINE
  
**      STEP 03- IF LIST OPTION SELECTED THEN STEP 6, ELSE ADVANCE
*                POINTER TO SOURCE THEN STEP 4. 
* 
          NZ     X5,CLIST9   IF LIST OPTION IS SELECTED 
          SA1    PSOURCE
          SX6    X1+6 
          SA6    A1          BUMP POINTER TO SOURCE CODE
  
**      STEP 04- ADVANCE LINE NUMBER THEN RETURN IF ALL LINES PROCESSED 
*                ELSE GO TO STEP 2. 
* 
 CLIST2   SB7    B7+B1       BUMP LINES POINTER 
          SA1    PSOURCE
          SA2    MSOURCE
          BX1    X1-X2
          NZ     X1,CLIST1   IF ALL LINES NOT PROCESSED 
          SA5    FLIST
          ZR     X5,CLIST    RETURN IF LIST NOT SELECTED
          IFNE   CMSE,0 
          MX6    0
          SA6    CLINE+LCLINE-1 
          SB2    CLINE
          RJ     PRINT       PRINT BLANK LINE 
          SA6    CLINE+LCLINE-1 
          RJ     PRINT       PRINT BLANK LINE 
          SA6    CLINE+LCLINE-1 
          RJ     PRINT       PRINT BLANK LINE 
          ENDIF 
          IFEQ   CMSE,0 
          SX1    CLISTC 
          RJ     LOADOVL           LOAD CROSS-REFERENCE OVERLAY 
          RJ     XREFM             PRINT CROSS REFERENCE
          ENDIF 
          EQ     CLIST       EXIT 
  
**      STEP 05- SET ERROR FLAG AND PRINT MESSAGE ON OUTPUT FILE THEN 
*                STEP 4.
* 
 CLIST3   SA7    FCERR       SET ERROR FLAG 
          RJ     CGETS       LINE NUMBER AND SOURCE CODE TO LINE BFR. 
          SB2    CLINE+7     FWA OF MESSAGE IN LINE BFR 
          SB3    CLINE+13    LWA +1 
          SA1    X7 
 CLIST4   BX6    X1 
          SA6    B2          MOVE MESSAGE TO LINE BUFFER
          SB2    B2+B1
          SA1    A1+B1       NEXT WORD OF MESSAGE 
          NE     B2,B3,CLIST4 
 CLIST5   SB2    CLINE
          SB1    B0          USE PAGING FORMAT FOR PRINTING 
          RJ     PRINT       PRINT LINE BUFFER
          SA1    FLINE
          SX2    7777B
          SB2    X1 
          NE     B2,B7,CLIST5A         IF NOT FIRST EXECUTABLE LINE 
          SA1    MODULE+4 
          AX1    36 
          SX3    3
          BX1    X1*X2       CODE BLOCK FWA 
          SA4    FCMSE
          SA4    X4+STACKAB        GET ABSOLUTE STACK LOCATION
          LX3    18 
          SX6    X1+MODULE
          LX4    36 
          BX6    X6+X3
          BX6    X6+X4
          SA6    PBIN        POINTER TO CODE BLOCK FOR BINARY 
 CLIST5A  SA1    B7          GET WORD FROM LINE BUFFER
          MX2    -12
          AX1    18 
          BX3    -X2*X1      NUMBER OF BINARY BYTES FOR THIS LINE 
          ZR     X3,CLIST2   IF NO BINARY 
          SA1    PBIN 
          SX6    X1          MODULE ADDRESS FOR NEXT BINARY 
          AX1    18 
          BX4    X1 
          SX1    X1          SHIFT COUNT FOR NEXT BYTE
          AX4    18          CURRENT PPU STACK ADDRESS FOR CODE 
          IX4    X4+X3       NEXT PPU STACK ADDRESS FOR CODE
          SA5    F16BIT      16-BIT FLAG
          ZR     X5,CLIST5D  IF NOT 16-BIT
          NE     B2,B7,CLIST5B IF NOT 1ST LINE OF EXECUTABLE CODE 
          SX1    13          BYTE POSITION IN THE NEXT WORD 
 CLIST5B  SX3    X3-3        BYTES PER WORD 
          NG     X3,CLIST5C 
          SX6    X6+B1       INCREMENT ADDRESS
          EQ     CLIST5B
 CLIST5C  SX3    X3+3 
          LX3    4           TIMES 16   FORM NEW SHIFT COUNT
          IX3    X3+X1       ADD OLD SHIFT COUNT
          SX2    X3-48
          NG     X2,CLIST8   IF NOT SHIFT COUNT OVERFLOW
          SX6    X6+B1       INCREMENT ADDRESS
          SX3    X3-48
          SA5    FLIST       RESTORE CURRENT LIST OPTION
          EQ     CLIST8 
 CLIST5D  SA5    FLIST       RESTORE CURRENT LIST OPTION
 CLIST6   SX3    X3-5 
          NG     X3,CLIST7   IF NOT A FULL WORD 
          SX6    X6+B1       BUMP MODULE ADDRESS
          EQ     CLIST6      PLAY IT AGAIN SAM
  
 CLIST7   SX3    X3+5 
          SX2    X3 
          LX3    3           TIMES 8
          LX2    2           TIMES 4
          IX3    X3+X2       TIMES 12    NEW SHIFT COUNT
          IX3    X3+X1       ADD OLD SHIFT COUNT
          SX2    X3-60
          NG     X2,CLIST8   IF NOT SHIFT COUNT OVERFLOW
          SX6    X6+B1       BUMP ADDRESS 
          SX3    X3-60
 CLIST8   LX3    18 
          BX6    X6+X3
          LX4    36 
          BX6    X4+X6       ADD PPU STACK ADDRESS FOR CODE 
          SA6    A1          RESTORE POINTER TO BINARY CODE 
          EQ     CLIST2 
  
**      STEP 06- PRINT LINE OF SOURCE AND BINARY CODE GENERATED THEN
*                STEP 4.
* 
 CLIST9   RJ     CGETS       LINE NUMBER AND SOURCE CODE TO LINE BFR. 
          SX2    7777B
          SA1    FLINE
          NZ     X1,CLIST11  IF THERE IS A CODE DIVISION
 CLIST10  SB2    CLINE
          SB1    B0          USE PAGING FORMAT FOR PRINTING 
          RJ     PRINT       PRINT CLINE BUFFER 
          EQ     CLIST2      GO PROCESS NEXT LINE 
  
 CLIST11  SB2    X1 
          LT     B7,B2,CLIST10  IF CODE DIVISION NOT REACHED YET
          NE     B2,B7,CLIST12  IF NOT FIRST LINE OF CODE DIVISION
          SA1    MODULE+4 
          AX1    36 
          SX3    3
          BX1    X1*X2       CODE BLOCK FWA 
          SA4    FCMSE
          SA4    X4+STACKAB        GET ABSOLUTE STACK LOCATION
          LX3    18 
          SX6    X1+MODULE
          LX4    36 
          BX6    X6+X3
          BX6    X6+X4       ADD PPU DRIVER STACK ADDRESS 
          SA6    PBIN        POINTER TO CODE BLOCK FOR BINARY 
 CLIST12  SA1    B7          GET WORD FROM LINES BUFFER 
          AX1    18 
          BX3    X1*X2       NUMBER OF BYTES OF BINARY FOR THIS LINE
          ZR     X3,CLIST10  IF NO BINARY 
          SA1    PBIN 
          SX0    X1          ADDRESS OF BINARY IN MODULE BUFFER 
          SB2    X3          NUMBER OF BYTES TO DO
          SB3    CLINE+7     FWA OF CLINE BUFFER FOR BINARY 
          AX1    18 
          SB4    X1          SHIFT COUNT FOR FIRST BYTE OF BINARY 
          SB5    4           CHARACTER LEFT TO DO IN A BYTE 
          SB6    60          MAX SHIFT COUNT
          SX3    1R          BLANK FILLER 
          SX4    7B          MASK 
          AX1    18 
          SX7    X1+B2       ADD CURRENT STACK ADDRESS AND BYTES
          SA7    CLISTB      SAVE IT FOR LATER INSERTION IN PBIN
          LX1    51          POSITION PPU STACK ADDRESS 
          SX6    1R          BLANK TO FIRST CHARACTER 
 CLIST12A LX6    6
          BX2    X4*X1       GET CHARACTER
          LX1    3
          SX2    X2+1R0      CONVERT IT TO DISPLAY CODE 
          BX6    X6+X2       ADD IT TO THE STRING 
          SB5    B5-B1       DECREMENT CHARACTERS TO DO 
          NZ     B5,CLIST12A IF NOT DONE
          SX2    1R=
          LX6    6
          BX6    X6+X2       ADD = SEPARATOR ON ADDRESS/DATA
          SB5    4           RESET CHARACTER COUNT
          SX7    B1          NUMBER OF BYTES FOR THE FIRST CM WORD
          SA1    X0          PRIME THE DATA WORD
          SA5    F16BIT      16-BIT FLAG
          ZR     X5,CLIST12I   IF NOT 16-BIT
          SA3    CLISTA      BLANKS 
          LX6    30 
          BX6    X6+X3       INSERT BLANKS
          LX6    42 
          MX3    42 
          BX6    X3*X6
          SX3    1R 
          LX3    12 
          BX6    X6+X3
          LX2    6
          BX6    X6+X2       INSERT = SIGN
          SX3    1R 
          BX6    X6+X3       INSERT A BLANK 
          SA6    B3          STORE DATA WORD
          SA3    CLISTD      BLANKS 
          SB3    CLISTE      DATA WORD BUFFER 
          MX6    0           CLEAR DATA WORD
          SX4    1B          SINGLE DIGIT MASK
          SA5    FLIST       RESTORE CURRENT LIST OPTION
          SB5    13          1ST BYTE OF THE WORD 
          GT     B4,B5,CLIS12A1 
          SB5    6           16-BIT CHARACTERS TO DO
          SB4    13          1ST BYTE OF THE WORD 
          EQ     CLIST12B    ENTER 16-BIT SEQUENCE
 CLIS12A1 SB5    6           16-BIT CHARACTERS TO DO
          SA5    FLIST       RESTORE CURRENT LIST OPTION
          EQ     CLIST12B    ENTER 16-BIT SEQUENCE
  
 CLIST12B LX6    6
          LX2    B4,X1       POSITION DIGITS TO BITS 0-2
          BX2    X2*X4       MASK DIGIT 
          SX2    X2+1R0      CONVERT DIGIT TO DISPLAY CODE
          BX6    X6+X2       ADD DIGIT TO STRING
          SB5    B5-B1       DECREMENT CHARACTERS TO DO 
          SB4    B4+3        INCREMENT SHIFT COUNT
          SX4    7B          RESTORE DIGITS MASK
          NZ     B5,CLIST12B IF MORE DIGITS IN THE BYTE 
          LX6    24 
          BX6    X6+X3       INSERT BLANKS
          SB4    B4-2        REPOSITION TO SINGLE BIT OF NEW BYTE 
          SB5    6           16-BIT CHARACTERS TO DO
          SX4    1B          SINGLE DIGIT MASK
          SX7    B1 
          LE     B4,B6,CLIST12C  IF MORE BYTES IN THE BINARY INPUT WORD 
          SB4    13          RESET SHIFT COUNT
          SA1    A1+B1       NEXT BINARY INPUT WORD 
 CLIST12C SA6    B3          STORE DATA WORD
          SB3    CLISTE+5    BUFFER LWA 
          SB3    A6-B3
          MX6    0           CLEAR DATA WORD
          ZR     B3,CLIST12D IF BUFFER FULL 
          SB3    A6+B1       INCREMENT BUFFER ADDRESS 
          SB2    B2-B1       DECREMENT BYTES TO DO
          ZR     B2,CLIST12D  IF DONE WITH BINARY FOR THIS SOURCE LINE
          EQ     CLIST12B    PROCESS NEXT BYTE
  
 CLIST12D SB3    CLINE+8
          SA2    CLISTE      DATA BUFFER FWA
          SA4    A2+B1       CLISTE+1 
          LX4    12 
          MX6    48 
          BX6    -X6*X4      EXTRACT LOWER 12 BITS
          BX6    X2+X6       FORM 10 CHARACTER WORD 
          SA6    B3          STORE  DATA WORD 
          SB3    A6+B1       CLINE+9
          BX6    X4          CLISTE+1 
          SA4    A4+B1       CLISTE+2 
          SA2    BLANKS      FULL WORD OF BLANKS
          BX2    X2-X4
          ZR     X2,CLIST12E IF NEXT BUFFER WORD IS BLANKS
          LX4    24 
          MX2    36 
          BX6    X2*X6
          BX2    -X2*X4      EXTRACT LOWER 24 BITS
          BX6    X6+X2       FORM 10 CHARACTER WORD 
          SA6    B3          STORE DATA WORD
          SB3    A6+B1       CLINE+10 
          BX6    X4          CLISTE+2 
          SA4    A4+B1       CLISTE+3 
          SA2    BLANKS      FULL WORD OF BLANKS
          BX2    X2-X4
          ZR     X2,CLIST12F IF NO BINARY FOR THIS LINE 
          LX4    36 
          MX2    24 
          BX6    X2*X6
          BX2    -X2*X4      EXTRACT LOWER 36 BITS
          BX6    X6+X2       FORM 10 CHARACTER WORD 
          SA6    B3          STORE DATA WORD
          SB3    A6+B1       CLINE+11 
          BX6    X4          CLISTE+3 
          SA4    A4+B1       CLISTE+4 
          SA2    BLANKS      FULL WORD OF BLANKS
          BX2    X2-X4
          ZR     X2,CLIST12G IF NO MORE BINARY FOR THIS LINE
          LX4    48 
          MX2    12 
          BX6    X2*X6
          BX2    -X2*X4      EXTRACT LOWER 12 BITS
          BX6    X6+X2       FORM 10 CHARACTER WORD 
          SA6    B3          STORE DATA WORD
          SB3    A6+B1       CLINE+12 
          SA4    A4+B1       CLISTE+5 
          SA2    BLANKS      FULL WORD OF BLANKS
          BX2    X2-X4
          ZR     X2,CLIST12G IF NO MORE BINARY FOR THIS LINE
          BX6    X4 
          SX4    5555B       BLANK LOWER 24 BITS
          BX6    X6+X4       INSERT BLANKS
          SA6    B3          STORE DATA WORD
          SB5    B4          SAVE CURRENT BYTE COUNT
          SB2    B2-B1       DECREMENT BYTES TO DO
          ZR     B2,CLIST19  IF DONE WITH BINARY FOR THIS LINE
          EQ     CLIST17     LINE IS FULL 
  
 CLIST12E MX2    30 
          BX6    X2*X6
          SA2    CLISTA      BLANKS 
          BX6    X6+X2       BLANK FILL LOWER 30 BITS 
          EQ     CLIST19     DONE WITH BINARY FOR THIS LINE 
  
 CLIST12F MX2    24 
          BX6    X2*X6
          SX2    1R 
          LX2    30 
          BX6    X6+X2
          SA2    CLISTA      BLANKS 
          BX6    X6+X2       BLANK LOWER 30 BITS
          EQ     CLIST19     DONE WITH BINARY FOR THIS LINE 
  
 CLIST12G BX6    X4 
          EQ     CLIST19     DONE WITH BINARY FOR THIS LINE 
  
 CLIST12I SA5    FLIST       RESTORE CURRENT LIST OPTION
          EQ     CLIST14     ENTER 12-BIT SEQUENCE
  
  
 CLIST13  BX6    X6+X3       BLANK TO FIRST CHARACTER 
 CLIST14  LX6    6
          LX2    B4,X1       POSITION DIGIT TO BITS 0 - 2 
          BX2    X2*X4       GET IT 
          SX2    X2+1R0      CONVERT IT TO DISPLAY CODE 
          BX6    X6+X2       ADD IT TO THE STRING 
          SB5    B5-B1       DECREMENT CHARACTERS IN THIS BYTE
          SB4    B4+3        BUMP SHIFT COUNT 
          NZ     B5,CLIST14  IF THE BYTE IS NOT USED UP 
          LE     B4,B6,CLIST15  IF BINARY INPUT WORD NOT USED UP
          SB4    3           RESET SHIFT COUNT
          SA1    A1+B1       BUMP BINARY ADDRESS - GET DATA WORD
 CLIST15  SB5    4           RESET DIGIT COUNTER
          SB2    B2-B1       DECREMENT BYTES TO DO
          ZR     B2,CLIST19  IF DONE
          SX7    X7-1 
          ZR     X7,CLIST16  IF A FULL OUTPUT WORD PACKED 
          LX6    6
          EQ     CLIST13     GO ADD BLANK AND DO SECOND BYTE
  
 CLIST16  SA6    B3          STORE DATA WORD
          SB3    CLINE+12 
          SB3    A6-B3
          SX7    B1+B1       RESET BYTES PER OUTPUT WORD
          MX6    0           CLEAR DATA WORD
          ZR     B3,CLIST17  IF LINE IS FULL
          SB3    A6+B1       BUMP STORAGE ADDRESS 
          EQ     CLIST13     GO ADD BLANK AND DO FIRST BYTE 
  
 CLIST17  MX6    0
          SA6    A6+B1       ZERO LAST WORD 
          SX2    B2          SAVE B2
          SX6    A1          SAVE A1
          SB2    CLINE
          SB1    B0          USE PAGING FORMAT FOR PRINTING 
          RJ     PRINT
          SA1    X6          RESTORE A1 
          SB2    X2          RESTORE B2 
          SA2    BLANKS 
          SB3    CLINE
 CLIST18  BX6    X2 
          SA6    B3          BLANK FILL  LINE BUFFER
          SB3    CLINE+12 
          SX6    A6-B3
          SB3    A6+B1
          NZ     X6,CLIST18 
          SB3    CLINE+7     RESET POINTER TO BINARY AREA OF LINE 
          SA2    CLISTA 
          SX7    B1          SET NUMBER OF BYTES TO ALLOW OFFSET
          BX6    X2          OFFSET WITH BLANKS 
          SA5    F16BIT      16-BIT FLAG
          ZR     X5,CLIST18A IF NOT 16-BIT FLAG 
          SA2    BLANKS      FULL WORD OF BLANKS
          BX6    X6+X2
          SA6    B3          BLANK PPU ADDRESS
          SB4    B5          RESTORE CURRENT BYTE COUNT 
          SB5    CLISTE      BUFFER FWA 
 CLIST18B BX6    X2 
          SA6    B5          BUFFER FWA 
          SB5    CLISTE+5    BUFFER LWA 
          SX6    A6-B5
          ZR     X6,CLIST18C IF BUFFER BLANK FILLED 
          SB5    A6+B1       INCREMENT BUFFER ADDRESS 
          EQ     CLIST18B    BLANK NEXT BUFFER WORD 
 CLIST18C SB3    CLISTE      BUFFER FWA 
          MX6    0           CLEAR DATA WORD
          SB5    6           16-BIT CHARACTERS TO DO
          SX4    1B          SINGLE DIGITS MASK 
          SA5    FLIST       RESTORE CURRENT LIST OPTION
          EQ     CLIST12B    PROCESS NEXT BYTE
 CLIST18A SA5    FLIST       RESTORE CURRENT LIST OPTION
          LX6    6
          EQ     CLIST13
  
 CLIST19  SX7    X7-1 
          SA2    BLANKS 
          SB5    CLINE+13    LWA + 1
          ZR     X7,CLIST20  IF OUTPUT DATA WORD IS FULL
          SA3    CLISTA      LOWER 30 BITS BLANKS 
          LX6    30 
          BX6    X6+X3       BLANK FILL LOWER HALF OF WORD
 CLIST20  SA6    B3          STORE WORD 
          BX6    X2 
          SB3    B3+B1
          NE     B3,B5,CLIST20    IF NOT DONE 
          SA5    F16BIT      16-BIT FLAG
          ZR     X5,CLIST20B IF NOT 16-BIT
          SB5    CLISTE      BUFFER FWA 
 CLIST20A BX6    X2 
          SA6    B5 
          SB5    CLISTE+5    BUFFER LWA 
          SB5    A6-B5
          ZR     B5,CLIST20B IF BUFFER BLANK FILLED 
          SB5    A6+B1       INCREMENT BUFFER ADDRESS 
          EQ     CLIST20A    IF BUFFER NOT BLANK FILLED 
 CLIST20B SA5    FLIST       RESTORE CURRENT LIST OPTION
          SX2    A1          ADDRESS OF NEXT MODULE BINARY WORD 
          SX6    B4          SHIFT COUNT FOR NEXT MODULE WORD 
          SA1    CLISTB      PPU STACK ADDRESS
          LX6    18 
          LX1    36 
          BX6    X6+X2
          BX6    X6+X1
          SA6    PBIN        SAVE BINARY POINTERS TO NEXT CODE
          MX6    0
          SA6    B3          ZERO LAST WORD OF BUFFER 
          SB2    CLINE
          SB1    B0          USE PAGING FORMAT FOR PRINTING 
          RJ     PRINT       PRINT A LINE 
          EQ     CLIST2      GO PROCESS NEXT LINE 
  
 CLISTA   DATA   5555555555B
 CLISTB   DATA   0           BUFFER FOR PPU STACK ADDRESS 
          IFEQ   CMSE,0,1 
 CLISTC   OVLTAB  7LMALET2Z,2,36
 CLISTD   DATA   55550000B
 CLISTE   DATA   55555555555555555555B
          DATA   55555555555555555555B
          DATA   55555555555555555555B
          DATA   55555555555555555555B
          DATA   55555555555555555555B
          DATA   55555555555555555555B
 PBIN     DATA   0           BUFFER FOR MODULE BUFFER POINTERS
          EJECT 
 CPSN     TITLE  CPSN - PROCESS STATEMENT NUMBERS FOR GOTO. 
**        CPSN - PROCESS STATEMENT NUMBERS FOR GOTO.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CPSN - PROCESS STATEMENT NUMBERS FOR GOTO STATEMENTS INTO 
*         THE LINES BUFFER. 
* 
*         ENTRY 
* 
*           (X2)     = STATEMENT NUMBER RIGHT JUSTIFIED.
*           (PLINES) = POINTER TO CURRENT WORD IN LINES BUFFER. 
* 
*         EXIT
* 
*           STATEMENT NUMBER, BYTE AND ADDRESS ARE STORED INTO THE
*           CURRENT LINES BUFFER WORD.  THIS IDENTIFIES WHERE CODE
*           STARTS IN THE MODULE BUFFER FOR THIS STATEMENT NUMBER.
* 
*         ROUTINES CALLED - CVTDIS
* 
*         DATA AREAS USED -  PLINES - POINTER TO LINES BUFFER.
*                            PSTORE - POINTER TO CODE IN MODULE BUFFER. 
* 
*         USES   A - 1, 3, 6. 
*                X - 1, 2, 3, 4, 6. 
*                B - NONE.
* 
  
 CPSN     DATA   0           ENTRY/EXIT 
          IFEQ   CMSE,0 
          BX6    X0 
          SA6    CPSNA             SAVE REGISTERS 
          BX6    X2 
          SA6    A6+B1
          BX1    X2 
          SA2    BASE 
          ZR     X2,CPSN1A   IF BASE OCTAL
          RJ     CVTDEC      CONVERT TO DECIMAL DISPLAY 
          EQ     CPSN2A      CONTINUE 
 CPSN1A   RJ     CVTDIS      CONVERT TO OCTAL DISPLAY 
 CPSN2A   MX1    48 
          BX3    -X1*X7            EXTRACT 2 DIGITS 
          BX2    X3 
          AX2    6
          SX2    X2-1R0 
          NZ     X2,CPSN1          IF FIRST DIGIT NOT ZERO
          MX1    54 
          BX3    -X1*X3 
          LX3    6
 CPSN1    LX3    48 
          MX1    1
          LX1    18 
          BX3    X3+X1             SET FLAG TO OMIT FROM GLOBAL MAP 
          RJ     CXREF             SAVE STATEMENT NUMBER REFERENCE
          SA1    CPSNA             RESTORE REGISTERS
          BX0    X1 
          SA1    A1+B1
          BX2    X1 
          ENDIF 
          SA1    PLINES      POINTER TO CURRENT LINE
          SA3    MODULE+4 
          MX6    48 
          LX3    24 
          BX6    -X6*X3 
          SA3    PSTORE      CURRENT POINTER FOR CODE IN MODULE BFR 
          LX2    54          POSITION STATEMENT NUMBER TO UPPER BITS
          MX4    36 
          BX3    -X4*X3 
          SX6    X6+MODULE
          IX3    X3-X6             MAKE ADDRESS RELATIVE
          MX4    42 
          BX6    X3*X4             EXTRACT SHIFT
          BX3    -X4*X3            EXTRACT ADDRESS
          LX6    30 
          BX2    X2+X6             MERGE SHIFT/4
          LX3    42                MERGE ADDRESS(RELATIVE)
          BX6    X3+X2
          SA1    X1 
          MX4    18 
          BX1    -X4*X1 
          BX6    X6+X1             MERGE EXISTING DATA
          SA6    A1                PUT DATA BACK IN LINES BUFFER
          EQ     CPSN        EXIT 
          IFEQ   CMSE,0,1 
 CPSNA    BSSZ   2
          EJECT 
 CSETP    TITLE  CSETP - GENERATE CODE TO STORE LINE NUMBER IN P
**        CSETP - GENERATE CODE TO STORE CURRENT LINE NUMBER IN P 
* 
*         K. B. SMITH. 78/04/11.
* 
*         CSETP -  GENERATES THE FOLLOWING CODE AND STORES IT IN
*         TH MODULE BUFFER: 
*                                  LDN/C LINE NUMBER
*                                  STD P
* 
*         ENTRY 
*                X0 MAT CONTAIN BINARY DATA 
* 
*         EXIT
*                X0 AND THE ABOVE CODE HAVE BEEN STORED 
* 
*         ROUTINES CALLED - CLOADC   - GENERATE LOAD INSTRUCTIONS 
*                           CSTOREB  - STORE COMPILED PPU CODE
* 
*         DATA AREAS USED - PLINES - CURRENT LINE POINTER 
*                           MODULE - BINARY PPU CODE STORED HERE
* 
*         USES   A - 1
*                X - 0,1,2
*                B - 2
 CSETP    DATA   0                 ENTRY/EXIT 
          SA1    PLINES 
          SX2    LINES
          IX2    X1-X2             CALCULATE LINE NUMBER
          SA1    ZPREG             GET LAST KNOWN P REG 
          BX7    X2 
          SA7    A1                SET NEW P REGISTER FLAG
          ZR     X1,CSETP1         IF UNKNOWN 
          IX1    X2-X1             LINES SINCE LAST SET 
          ZR     X1,CSETP5         IF P IS CURRENT(NO CODE NEEDED)
          SX1    X1-1 
          ZR     X1,CSETP2         IF SET LAST LINE 
          SX1    X1-77B 
          MI     X1,CSETP3         IF .LE. 77B LINES SINCE LAST SET 
 CSETP1   SB2    3
          RJ     CLOADC            GENERATE LOAD INSTRUCTIONS 
          SX1    STD+P
          EQ     CSETP4 
 CSETP2   SX1    AOD+P             CODE IS AOD  P 
          EQ     CSETP4 
 CSETP3   SX1    X1+100B+LDN       CODE IS LDN DELTA, RAD  P
          LX0    12 
          BX0    X0+X1
          SX1    RAD+P
 CSETP4   LX0    12 
          BX0    X0+X1
 CSETP5   RJ     CSTOREB           STORE BINARY CODE
          EQ     CSETP             RETURN 
          EJECT 
 CSTORE   TITLE  CSTORE - GENERATE PPU CODE FOR STM.
**        CSTORE - GENERATE PPU CODE FOR STM. 
* 
*         K.B. SMITH. 78/05/09. 
* 
*         CSTORE - GENERATE PPU CODE THAT PERFORMS ONE OF THE 
*         FOLLOWING STORE OPERATIONS, AND ADD IT TO X0 REGISTER.
* 
*                STD REGISTER 
*                STM BUFFER 
*                STM BUFFER + VALUE 
*                STM BUFFER (REGISTER)
* 
*         ENTRY  (B2) = DESCRIPTOR FOR THE CONTENTS OF B3 AND X2. 
* 
*         EXIT   TO CSTORE. 
* 
*         ROUTINES CALLED - CSTOREB 
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - NONE.
*                X - 0, 7.
*                B - 4. 
* 
  
 CSTORE   DATA   0           ENTRY/EXIT 
          RJ     CSTOREB     STORE CODE IN X0 
          ZR     B2,CST3     IF BUFFER(REGISTER)
          EQ     B2,B1,CST4  IF BUFFER
          SX7    B3-100B
          PL     X7,CST1     IF NON-DIRECT REGISTER 
          SX0    B3+STD      CODE = STD REGISTER
          EQ     CST6 
  
 CST1     SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,CST161   IF 16 BIT SET
          SX0    STM
          LX0    12 
          SX7    B3 
          BX0    X0+X7       CODE = STM REGISTER
          EQ     CST6 
 CST161   SX0    STM
          LX0    24 
          SX7    B3 
          BX0    X0+X7       CODE = STM REGISTER
          EQ     CST6 
 CST3     SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,CST163   IF 16 BIT SET
          SX7    B3-100B
          PL     X7,CST5     IF NON-DIRECT REGISTER 
 CST4     SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,CST164   IF 16 BIT SET
          SX0    STM
          LX0    12 
          BX0    X0+X2       CODE = STM BUFFER(REGISTER)
          EQ     CST6 
 CST163   SX7    B3-100B
          PL     X7,CST165   IF NON-DIRECT REGISTER 
          MX7    6           SET MASK 
          LX7    24          SET MASK FOR REGISTER VALUE
          BX0    X2*X7       EXTRACT REGISTER VALUE 
          LX0    6           POSITION REGISTER VALUE
          MX7    -18         SET MASK FOR 16 BIT ADDRESS
          BX2    -X7*X2      CLEAR ALL OTHER BITS 
          BX2    X2+X0       RESTORE X2 WITH SHIFTED VALUE
 CST164   SX0    STM
          LX0    24 
          BX0    X0+X2       CODE = STM BUFFER(REGISTER)
          EQ     CST6 
 CST165   SX0    STD+YREG 
          SX7    LDM
          LX0    24 
          BX0    X0+X7       CODE = STD YREG
          LX0    12 
          SX7    B3 
          BX0    X0+X7              LDM REGISTER
          LX0    12 
          SX7    STD+XREG 
          BX0    X0+X7              STD XREG
          RJ     CSTOREB
          SX0    LDD+YREG           LDD YREG
          LX0    12 
          SX7    STM+XREG 
          BX0    X0+X7
          LX0    24 
          MX7    -24
          BX7    -X7*X2 
          BX0    X0+X7              STM BUFFER(XREG)
          EQ     CST6 
 CST5     SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,CST165   IF 16 BIT SET
          SX0    STD+YREG 
          SX7    LDM
          LX0    12 
          BX0    X0+X7       CODE = STD YREG
          LX0    12 
          SX7    B3 
          BX0    X0+X7              LDM REGISTER
          LX0    12 
          SX7    STD+XREG 
          BX0    X0+X7              STD XREG
          RJ     CSTOREB
          SX0    LDD+YREG           LDD YREG
          LX0    12 
          SX7    STM+XREG 
          BX0    X0+X7
          LX0    12 
          MX7    -12
          BX7    -X7*X2 
          BX0    X0+X7              STM BUFFER(XREG)
 CST6     RJ     CSTOREB
          EQ     CSTORE      EXIT 
          EJECT 
 CSTOREB  TITLE  CSTOREB - STORE COMPILED PPU CODE INTO THE MODULE. 
**        CSTOREB - STORE COMPILED PPU CODE INTO THE MODULE.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CSTOREB - STORE COMPILED PPU CODE INTO THE MODULE BUFFER. 
*         THIS ROUTINE MAINTAINS POINTERS TO THE MODULE BUFFER THAT 
*         IDENTIFY THE CURRENT WORD AND BYTE THAT IS TO RECIEVE THE 
*         NEXT BINARY CODE STORED. IT ALSO UPDATES A COUNTER TO 
*         INDICATE THE NUMBER OF BYTES STORED.
* 
*         ENTRY 
* 
*           X0 = BINARY PPU DATA TO BE STORED, RIGHT JUSTIFIED, ZERO
*                FILLED. DATA BYTES ARE STORED FROM LEFT TO RIGHT,
*                STARTING WITH THE FIRST NON-ZERO BYTE FOUND AND
*                CONTINUING UNTIL ALL BYTES OF THE REGISTER ARE  DONE.
* 
*           CAUTION.. THE FIRST BYTE TO BE STORED CAN NEVER BE ZERO.
* 
*         EXIT
* 
*           . BINARY PPU CODE STORED INTO THE MODULE BUFFER 
*           . FCERR COMPILER ERROR FLAG IS SET IF THE SIZE OF MODULE
*             BUFFER IS EXCEEDED. 
*           . X0 REGISTER IS ZEROED.
*           . PSTORE IS UPDATED TO INDICATE THE NUMBER OF BYTES STORED. 
* 
*         ROUTINES CALLED -  CSTOREH - STORE GENERATED 16-BIT CODE
*                                      WHEN COMPILING A 16-BIT MODULE.
* 
*         DATA AREAS USED -  MODULE - BINARY CODE STORED HERE.
*                            PSTORE - POINTER TO NEXT MODULE WORD/BYTE. 
*                            FCERR  - COMPILER ERROR FLAG 
* 
*         USES   A - 1, 5, 6. 
*                X - 0,1,5,6,7. 
*                B - 4. 
* 
  
 CSTOREB  DATA   0           ENTRY/EXIT 
          BX7    X2 
          SA7    CSBA        SAVE X2
          SX2    B2 
          SX7    B3 
          LX7    18 
          BX7    X7+X2
          SA7    A7+B1       SAVE B2,B3 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CSB0     IF NOT 16-BIT
          BX7    X4 
          SA7    SREG4       SREG4 = -IF- JUMP CODE SAVED 
          RJ     CSTOREH     STORE COMPILED 16-BIT PP CODE
          SA4    SREG4       (X4) = -IF- JUMP CODE RESTORED 
          EQ     CSB5        EXIT 
  
 CSB0     SA1    PSTORE      POINTER TO MODULE BUFFER 
          SX7    B1          BYTES INCREMENT WORD 
          SB2    X1          MODULE ADDRESS 
          AX1    18 
          SB3    X1          SHIFT COUNT FOR NEXT BYTE
          AX1    18          NUMBER OF BYTES STORED 
          SA5    B2          WORD FROM MODULE BUFFER
          SA2    CLAST       LAST WORD+1 THAT CODE CAN BE STORED
          SB4    X2 
          SX6    B2-B4
          SX2    7777B       MASK 
          SB4    5           BYTES TO PROCESS 
          NG     X6,CSB      IF CODE LENGTH NOT EXCEEDED
          SX6    MSG8 
          SA6    FCERR       SET ERROR FLAG 
          MX0    0           CLEAR DATA REGISTER
          EQ     CSB5 
  
 CSB      LX0    12 
          BX6    X0*X2       GET NEXT BYTE
          NZ     X6,CSB1     IF FIRST VALID BYTE FOUND
          SB4    B4-B1
          NE     B4,B0,CSB   IF ALL BYTES NOT SCANNED 
          EQ     CSB5 
  
 CSB1     LX6    B3,X6       PUT BYTE INTO CORRECT POSITION 
          BX5    X5+X6       MERGE BYTE 
          SB3    B3-12       DECREMENT SHIFT COUNT
          PL     B3,CSB2     IF WORD NOT FULL 
          BX6    X5 
          SA6    B2          STORE FULL WORD
          SB3    48          RESET SHIFT COUNT
          SB2    B2+B1       ADVANCE POINTER TO MODULE BUFFER 
          SA5    CLAST
          SX6    B2 
          IX6    X5-X6
          SA5    B2          GET NEXT WORD FROM MODULE BUFFER 
          SB4    B4-B1
          IX1    X1+X7       BUMP BYTES STORED
          ZR     B4,CSB3     IF ALL BYTES DONE
          NZ     X6,CSB2A    IF MODULE BUFFER NOT FULL
          SX6    MSG8        MODULE  BUFFER FULL MESAGE 
          SA6    FCERR       SET COMPILER ERROR FLAG
          MX0    0           CLEAR DATA REGISTER
          EQ     CSB5 
  
 CSB2     SB4    B4-B1
          IX1    X1+X7       BUMP BYTES STORED
          EQ     B4,B0,CSB3  IF ALL BYTES DONE
 CSB2A    LX0    12 
          BX6    X0*X2       GET NEXT BYTE
          EQ     CSB1 
  
 CSB3     SX0    B3 
          LX1    36 
          ZR     X5,CSB4     IF NO DATA TO STORE
          BX6    X5 
          SA6    B2          STORE GENERATED WORD 
 CSB4     SX6    B2 
          LX0    18 
          BX6    X6+X0
          MX0    0           CLEAR CODE PROCESSING WORD 
          BX6    X6+X1       BYTES STORED 
          SA6    PSTORE      RESTORE POINTERS TO MODULE BUFFER
 CSB5     SA2    CSBA+1 
          SB2    X2          RESTORE B2 
          AX2    18 
          SB3    X2          RESTORE B3 
          SA2    A2-B1       RESTORE X2 
          EQ     CSTOREB     EXIT 
  
 CSBA     BSS    2
 CLAST    BSSZ   1           BUFFER FOR LWA+1 WHERE CODE CAN BE STORED
 PSTORE1  DATA   0
  
**        THE FORMAT OF THE PSTORE WORD IS AS FOLLOWS;
* 
*          59       47       35           17          0 
*         ----------------------------------------------
*         I        I BYTES  I   BYTE     I             I
*         I TOTAL  I FOR    I  SHIFT     I   MODULE    I
*         I BYTES  I THIS   I  COUNT     I   ADDRESS   I
*         I        I LINE   I            I             I
*         ----------------------------------------------
* 
 PSTORE   VFD    24/0,18/48,18/MODULE 
 SREG4    DATA   0           SAVE -IF- JUMP CODE
          EJECT 
 CSTORED  TITLE  CSTORED - STORE COMPILED PPU DATA INTO THE MODULE. 
**        CSTORED - STORE COMPILED PPU DATA INTO THE MODULE.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         CSTORED - STORE COMPILED PPU DATA INTO THE MODULE BUFFER. 
*         THIS ROUTINE MAINTAINS POINTERS TO THE MODULE BUFFER THAT 
*         IDENTIFY THE CURRENT WORD AND BYTE THAT IS TO RECIEVE THE 
*         NEXT BINARY DATA STORED.
* 
*         ENTRY 
* 
*           X0 = BINARY PPU DATA TO BE STORED. ALL BYTES OF THE 
*                REGISTER ARE STORED. 
*         EXIT
* 
*           . BINARY PPU DATA STORED INTO THE MODULE BUFFER 
*           . FCERR COMPILER ERROR FLAG IS SET IF THE SIZE OF MODULE
*             BUFFER IS EXCEEDED. 
*           . X0 REGISTER IS ZEROED.
*           . PSTORED IS UPDATED TO INDICATE THE NEXT WORD/BYTE TO
*             STORE.
* 
*         ROUTINES CALLED -  CSTORHD - STORE GENERATED 16-BIT DATA
*                                      WHEN COMPILING A 16-BIT MODULE.
* 
*         DATA AREAS USED -  MODULE - BINARY CODE STORED HERE.
*                            PSTORE - POINTER TO NEXT MODULE WORD/BYTE. 
*                            FCERR  - COMPILER ERROR FLAG 
* 
*         USES   A - 1, 6.
*                B - 2, 3, 7. 
*                X - 0, 1, 2, 6.
* 
*         MESSAGES
* 
  
 CSTORED  DATA   0           ENTRY/EXIT 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,CSD0     IF NOT 16-BIT
          RJ     CSTORHD     STORE COMPILED 16-BIT DATA 
          EQ     CSTORED     EXIT 
  
 CSD0     SA1    PSTORED     GET POINTER TO MODULE BUFFER 
          SB2    X1          MODULE ADDRESS 
          AX1    18 
          SB3    X1          SHIFT COUNT FOR NEXT BYTE
          SX1    DATA 
          SX6    B2 
          IX6    X6-X1
          BX1    X6 
          LX6    2          MULTIPLY BY 4 
          IX6    X6+X1      MULTIPLY BY 5 
          SA1    FINDMAX
          IX6    X6-X1
          PL     X6,CSD1A   IF OVERFLOW ON BYTES ALLOWED
          MX2    -12         BYTE MASK
          SB7    5           NUMBER OF BYTES TO STORE 
          SA1    B2          GET NEXT WORD FROM MODULE BUFFER 
 CSD1     LX0    12 
          BX6    -X2*X0      GET NEXT BYTE TO STORE 
          BX0    X2*X0       CLEAR BYTE STORED
          LX6    B3,X6       POSITION THE BYTE
          BX1    X1+X6       MERGE THIS BYTE WITH OLD DATA
          SB3    B3-12
          PL     B3,CSD2     IF WORD NOT FULL 
          BX6    X1 
          SA6    B2          STORE THE FULL WORD
          SB3    48          RESET SHIFT COUNT
          SX1    DATA 
          SX6    B2 
          IX6    X6-X1
          SX6    X6+B1
          SX1    X6 
          LX6    2           WORDS TIMES 4
          IX6    X6+X1       WORDS TIMES 5 - NUMBER OF PPU BYTES
          SA1    FINDMAX     MAXIMUM NUMBER OF BYTES ALLOWED
          IX6    X6-X1
          SB2    B2+B1       ADVANCE POINTER TO THE MODULE BUFFER 
          SA1    B2          GET NEXT WORD
          NG     X6,CSD2     IF MODULE DATA BLOCK NOT FULL
          ZR     X0,CSD3     IF DATA TO STORE IS ZERO 
 CSD1A    SX6    MSG8 
          SA6    FCERR       SET COMPILER ERROR FLAG
          MX0    0           CLEAR DATA WORD
          EQ     CSTORED     EXIT 
  
 CSD2     SB7    B7-B1
          NZ     B7,CSD1     IF ALL BYTES NOT STORED
          BX6    X1 
          SA6    B2          STORE LAST WORD
 CSD3     SX0    B3 
          SX6    B2 
          LX0    18 
          BX6    X0+X6
          MX0    0           CLEAR DATA WORD
          SA6    PSTORED     STORE POINTERS FOR NEXT STORE
          EQ     CSTORED     EXIT 
  
 PSTORED  DATA   0           BUFFER FOR MODULE POINTER
          EJECT 
 CSTOREH  TITLE  CSTOREH - STORE COMPILED 16-BIT PPU CODE INTO THE MODULE.
**        CSTOREH - STORE COMPILED 16-BIT PPU CODE INTO THE MODULE. 
* 
*         J. E. SIPPER. 76/12/08. 
*         M. S. FABBRINI. 82/07/21.  ADAPTED TO 16-BIT MALET USE. 
* 
*         CSTOREH - STORE COMPILED 16-BIT PPU CODE INTO THE MODULE BUFFER.
*         THIS ROUTINE MAINTAINS POINTERS TO THE MODULE BUFFER THAT 
*         IDENTIFY THE CURRENT WORD AND BYTE THAT IS TO RECIEVE THE 
*         NEXT BINARY CODE STORED. IT ALSO UPDATES A COUNTER TO 
*         INDICATE THE NUMBER OF BYTES STORED.
* 
*         ENTRY 
* 
*           X0 = 16-BIT BINARY PPU DATA TO BE STORED, RIGHT JUSTIFIED, ZERO 
*                FILLED. DATA BYTES ARE STORED FROM LEFT TO RIGHT,
*                STARTING WITH THE FIRST NON-ZERO BYTE FOUND AND
*                CONTINUING UNTIL ALL BYTES OF THE REGISTER ARE  DONE.
* 
*           CAUTION.. THE FIRST BYTE TO BE STORED CAN NEVER BE ZERO.
* 
*         EXIT
* 
*           . 16-BIT BINARY PPU CODE STORED INTO THE MODULE BUFFER
*           . FCERR COMPILER ERROR FLAG IS SET IF THE SIZE OF MODULE
*             BUFFER IS EXCEEDED. 
*           . X0 REGISTER IS ZEROED.
*           . PSTORE IS UPDATED TO INDICATE THE NUMBER OF BYTES STORED. 
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  MODULE - BINARY CODE STORED HERE.
*                            PSTORE - POINTER TO NEXT MODULE WORD/BYTE. 
*                            FCERR  - COMPILER ERROR FLAG 
* 
*         USES   A - 1, 5, 6. 
*                X - 0,1,5,6,7. 
*                B - 4, 5, 6. 
* 
  
 CSTOREH  DATA   0           ENTRY/EXIT 
          MX6    0
          SA6    FLMINS 
          SA6    FLCINS 
          SA1    PSTORE      POINTER TO MODULE BUFFER 
          SX7    B1          BYTES INCREMENT WORD 
          SB2    X1          MODULE ADDRESS 
          AX1    18 
          SB3    X1          SHIFT COUNT FOR NEXT BYTE
          AX1    18          NUMBER OF BYTES STORED 
          SA5    B2          WORD FROM MODULE BUFFER
          SA2    CLAST       LAST WORD+1 THAT CODE CAN BE STORED
          SB4    X2 
          SX6    B2-B4
          SX2    7777B       MASK 
          SB4    5           BYTES TO PROCESS 
          NG     X6,CSH      IF CODE LENGTH NOT EXCEEDED
          SX6    MSG8 
          SA6    FCERR       SET ERROR FLAG 
          MX0    0           CLEAR DATA REGISTER
          EQ     CSTOREH     EXIT 
  
 CSH      LX0    12 
          BX6    X0*X2       GET NEXT BYTE
          NZ     X6,CSH1     IF FIRST VALID BYTE FOUND
          SB4    B4-B1
          NE     B4,B0,CSH   IF ALL BYTES NOT SCANNED 
          EQ     CSTOREH     EXIT 
  
 CSH1     SA4    FLMINS      MEMORY ADDRESS FLAG
          ZR     X4,CSH1A    IF NOT MEMORY ADDRESS
          MX6    0
          SA6    FLMINS      CLEAR MEMORY ADDRESS FLAG
          SX2    17777B      ALLOW FOR MEMORY ADDRESS 8K PP 
          SA4    FLCINS 
          ZR     X4,CSH1AA   IF NOT CONSTANT INSTRUCTION
          SX2    7777B       SET FOR 12 BIT CHECK 
          MX6    0
          SA6    FLCINS      CLEAR CONSTANT INSTRUCTION FLAG
 CSH1AA   EQ     CSH1F       IF MEMORY ADDRESS
  
 CSH1A    AX6    6
          SX6    X6-30B      L.T. 30 OP-CODE INSTRUCTION RANGE
          NG     X6,CSH1B    IF MEMORY INSTRUCTION
          SX6    X6-17B      G.T. 47 OP-CODE INSTRUCTION RANGE
          ZR     X6,CSH1C    IF LONG MEMORY INSTRUCTION AND NO ADDRESS
          PL     X6,CSH1D    IF LONG MEMORY INSTRUCTION 
 CSH1C    BX6    X0*X2
          SX6    X6+100000B  SET LONG INSTRUCTION 
          EQ     CSH1G
  
 CSH1B    BX6    X0*X2
          AX6    6
          ZR     X6,CSH1F    IF PASS INSTRUCTION
          SX6    X6-3B       JUMP INSTRUCTION RANGE 
          NG     X6,CSH1E    IF JUMP INSTRUCTION
          BX6    X0*X2
          AX6    6
          SX6    X6-20B      L.T. 20 OP-CODE INSTRUCTION RANGE
          NG     X6,CSH1F    IF NOT MEMORY INSTRUCTION
          SX6    X6-3B       G.T. 23 OP-CODE INSTRUCTION RANGE
          ZR     X6,CSH1E    IF CONSTANT INSTRUCTION
          PL     X6,CSH1F    IF NOT MEMORY INSTRUCTION
 CSH1E    SX6    B1 
          SA6    FLMINS      SET MEMORY ADDRESS FLAG
          SA6    FLCINS      SET FOR CONSTANT INSTRUCTION 
          SX2    7777B       SET FOR 12 BIT CHECK 
          EQ     CSH1F
  
 CSH1D    BX6    X0*X2
          AX6    6
          SX6    X6-60B      G.T. 57 OP-CODE INSTRUCTION RANGE
          PL     X6,CSH1F    IF NOT LONG MEMORY INSTRUCTION 
          BX6    X0*X2
          SX6    X6+100000B  SET LONG INSTRUCTION 
          SA7    FLMINS      SET MEMORY ADDRESS FLAG
          EQ     CSH1H
  
 CSH1F    BX6    X0*X2       RESTORE X6 
 CSH1G    LX6    B3,X6       PUT BYTE INTO CORRECT POSITION 
          BX5    X5+X6       MERGE BYTE 
          SX2    7777B       SET FOR 12 BIT CHECK 
          SB3    B3-16       DECREMENT SHIFT COUNT
          PL     B3,CSH2     IF WORD NOT FULL 
          BX6    X5 
          SA6    B2          STORE FULL WORD
          SB3    32          RESET SHIFT COUNT
          SB2    B2+B1       ADVANCE POINTER TO MODULE BUFFER 
          SA5    CLAST
          SX6    B2 
          IX6    X5-X6
          SA5    B2          GET NEXT WORD FROM MODULE BUFFER 
          SB4    B4-B1
          IX1    X1+X7       BUMP BYTES STORED
          ZR     B4,CSH3     IF ALL BYTES DONE
          NZ     X6,CSH2A    IF MODULE BUFFER NOT FULL
          SX6    MSG8        MODULE  BUFFER FULL MESAGE 
          SA6    FCERR       SET COMPILER ERROR FLAG
          MX0    0           CLEAR DATA REGISTER
          EQ     CSTOREH     EXIT 
  
 CSH2     SB4    B4-B1
          IX1    X1+X7       BUMP BYTES STORED
          EQ     B4,B0,CSH3  IF ALL BYTES DONE
 CSH2A    LX0    12 
          BX6    X0*X2       GET NEXT BYTE
          EQ     CSH1 
  
 CSH3     SX0    B3 
          LX1    36 
          ZR     X5,CSH4     IF NO DATA TO STORE
          BX6    X5 
          SA6    B2          STORE GENERATED WORD 
 CSH4     SX6    B2 
          LX0    18 
          BX6    X6+X0
          MX0    0           CLEAR CODE PROCESSING WORD 
          BX6    X6+X1       BYTES STORED 
          SA6    PSTORE      RESTORE POINTERS TO MODULE BUFFER
          EQ     CSTOREH     EXIT 
 CSH1H    LX6    B3,X6       PUT BYTE INTO CORRECT POSITION 
          BX5    X5+X6       MERGE BYTE 
          SB3    B3-16       DECREMENT SHIFT COUNT
          PL     B3,CSH2H    IF WORD NOT FULL 
          BX6    X5 
          SA6    B2          STORE FULL WORD
          SB3    32          RESET SHIFT COUNT
          SB2    B2+B1       ADVANCE POINTER TO MODULE BUFFER 
          SA5    CLAST
          SX6    B2 
          IX6    X5-X6
          SA5    B2          GET NEXT WORD FROM MODULE BUFFER 
          SB4    B4-B1
          SB4    B4-B1
          IX1    X1+X7       BUMP BYTES STORED
          ZR     B4,CSH3H    IF ALL BYTES DONE
          NZ     X6,CSH2AH   IF MODULE BUFFER NOT FULL
          SX6    MSG8        MODULE  BUFFER FULL MESSAGE
          SA6    FCERR       SET COMPILER ERROR FLAG
          MX0    0           CLEAR DATA REGISTER
          EQ     CSTOREH     EXIT 
  
 CSH2H    SB4    B4-B1
          SB4    B4-B1
          IX1    X1+X7       BUMP BYTES STORED
          EQ     B4,B0,CSH3  IF ALL BYTES DONE
 CSH2AH   LX0    24 
          BX6    X0*X2       GET NEXT BYTE
          EQ     CSH1 
  
 CSH3H    SX0    B3 
          LX1    36 
          ZR     X5,CSH4     IF NO DATA TO STORE
          BX6    X5 
          SA6    B2          STORE GENERATED WORD 
 CSH4H    SX6    B2 
          LX0    18 
          BX6    X6+X0
          MX0    0           CLEAR CODE PROCESSING WORD 
          BX6    X6+X1       BYTES STORED 
          SA6    PSTORE      RESTORE POINTERS TO MODULE BUFFER
          EQ     CSTOREH     EXIT 
  
 FLMINS   DATA   0           MEMORY ADDRESS FLAG
 FLCINS   DATA   0           CONSTANT INSTRUCTION FLAG
          EJECT 
 CSTORHD  TITLE  CSTORHD - STORE COMPILED 16-BIT PPU DATA INTO THE MODULE.
**        CSTORHD - STORE COMPILED 16-BIT PPU DATA INTO THE MODULE. 
* 
*         J. E. SIPPER. 76/12/08. 
*         M. S. FABBRINI. 82/07/21.   ADAPTED FOR MALET 16-BIT USE. 
* 
*         CSTORHD - STORE COMPILED 16-BIT PPU DATA INTO THE MODULE BUFFER.
*         THIS ROUTINE MAINTAINS POINTERS TO THE MODULE BUFFER THAT 
*         IDENTIFY THE CURRENT WORD AND BYTE THAT IS TO RECIEVE THE 
*         NEXT BINARY DATA STORED.
* 
*         ENTRY 
* 
*           X0 = 16-BIT BINARY PPU DATA TO BE STORED LEFT JUSTIFIED, ZERO 
*                FILLED.  DATA BYTES ARE STORED FROM LEFT TO RIGHT
*                UNTIL ALL BYTES OF THE REGISTER ARE STORED.
* 
*         EXIT
* 
*           . 16-BIT BINARY PPU DATA STORED INTO THE MODULE BUFFER
*           . FCERR COMPILER ERROR FLAG IS SET IF THE SIZE OF MODULE
*             BUFFER IS EXCEEDED. 
*           . X0 REGISTER IS ZEROED.
*           . PSTORED IS UPDATED TO INDICATE THE NEXT WORD/BYTE TO
*             STORE.
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  MODULE - BINARY CODE STORED HERE.
*                            PSTORE - POINTER TO NEXT MODULE WORD/BYTE. 
*                            FCERR  - COMPILER ERROR FLAG 
* 
*         USES   A - 1, 6.
*                B - 2, 3, 7. 
*                X - 0, 1, 2, 6.
* 
*         MESSAGES
* 
  
 CSTORHD  DATA   0           ENTRY/EXIT 
          SA1    PSTORED     GET POINTER TO MODULE BUFFER 
          SB2    X1          MODULE ADDRESS 
          AX1    18 
          SB3    X1          SHIFT COUNT FOR NEXT BYTE
          SX1    DATA 
          SX6    B2 
          IX6    X6-X1
          BX1    X6 
          LX6    1           MULTIPLY BY 3
          IX6    X6+X1       NUMBER OF 16-BIT PPU BYTES PER CM WORD 
          SA1    FINDMAX
          IX6    X6-X1
          PL     X6,CSHD1A   IF OVERFLOW ON BYTES ALLOWED 
          LX0    12          POSITION BYTES TO PROCESS
          MX2    -16         BYTE MASK
          SB7    3           NUMBER OF BYTES TO STORE 
          SA1    B2          GET NEXT WORD FROM MODULE BUFFER 
 CSHD1    LX0    16 
          BX6    -X2*X0      GET NEXT BYTE TO STORE 
          BX0    X2*X0       CLEAR BYTE STORED
          LX6    B3,X6       POSITION THE BYTE
          BX1    X1+X6       MERGE THIS BYTE WITH OLD DATA
          SB3    B3-16
          PL     B3,CSHD2    IF WORD NOT FULL 
          BX6    X1 
          SA6    B2          STORE THE FULL WORD
          SB3    32          RESET SHIFT COUNT
          SX1    DATA 
          SX6    B2 
          IX6    X6-X1
          SX6    X6+B1
          SX1    X6 
          LX6    1           MULTIPLY BY 3
          IX6    X6+X1       NUMBER OF 16-BIT PPU BYTES PER CM WORD 
          SA1    FINDMAX     MAXIMUM NUMBER OF BYTES ALLOWED
          IX6    X6-X1
          SB2    B2+B1       ADVANCE POINTER TO THE MODULE BUFFER 
          SA1    B2          GET NEXT WORD
          NG     X6,CSHD2    IF MODULE DATA BLOCK NOT FULL
          ZR     X0,CSHD3    IF DATA TO STORE IS ZERO 
 CSHD1A   SX6    MSG8 
          SA6    FCERR       SET COMPILER ERROR FLAG
          MX0    0           CLEAR DATA WORD
          EQ     CSTORHD     EXIT 
  
 CSHD2    SB7    B7-B1
          NZ     B7,CSHD1    IF ALL BYTES NOT STORED
          BX6    X1 
          SA6    B2          STORE LAST WORD
 CSHD3    SX0    B3 
          SX6    B2 
          LX0    18 
          BX6    X0+X6
          MX0    0           CLEAR DATA WORD
          SA6    PSTORED     STORE POINTERS FOR NEXT STORE
          EQ     CSTORHD     EXIT 
          EJECT 
 CVTHEX   TITLE  CVTHEX - HEXADECIMAL DISPLAY CODE TO BINARY CONVERSION.
**        CVTHEX - HEXADECIMAL DISPLAY CODE TO BINARY CONVERSION. 
* 
*         P. D. FARRELL      77/02/16.
*         G. L. GOLDEN       80/03/21.  ADAPTED TO MALET USE
*         M. S. FABBRINI     82/07/23.  ADAPTED TO MALET 16-BIT USE 
* 
*         ENTRY  - (X5) = WORD TO BE CONVERTED. 
* 
*         EXIT   - (X6) = CONVERTED HEXADECIMAL DIGITS. 
*                  (X4) = NON-ZERO IF ERROR DETECTED
* 
*         USES   X - 2, 3, 4, 5, 6. 
*                B - 3, 4, 5. 
* 
*         CALLS  - NONE.
* 
 CVTHEX   DATA   0
          SB3    -1RG        (B3) = -1RG
          MX4    -6          (X4) = DIGIT MASK
          BX6    X6-X6       CLEAR ASSEMBLY 
          SB4    -1RZ        (B4) = -1RZ
          SB5    -1RH        (B5) = -1RH
  
 HEX1     ZR     X5,CVTHEX   IF ZERO WORD, RETURN ERROR 
          LX5    6           EXTRACT UPPER DIGIT
          BX2    -X4*X5      (X2) = DISPLAY CODE DIGIT
          SX3    X2+B5
          BX5    X4*X5       CLEAR DIGIT
          NZ     X3,HEX2     IF NOT RADIX H 
          SX4    B1 
          EQ     CVTHEX      RETURN WE HAD ERROR
  
*         CONVERT DIGITS TO TRAILING SPACE. 
  
 HEX2     SX3    X2+B5       CHECK DIGIT
          LX5    6
          ZR     X3,CVTHEX   IF  RADIX H, RETURN ERROR
          SX3    X2+B3
          NG     X3,HEX3     IF A-F 
          SX3    X2+B4
          NG     X3,CVTHEX   IF G-Z, RETURN ERROR 
          SX3    X2-1R9-1 
          PL     X3,CVTHEX   IF .GT. 9, RETURN ERROR
          SX2    X2-1R0+1RA-0#A  BIAS FOR 0-9 CONVERSION  777733B 
 HEX3     SX2    X2-1RA+0#A  CONVERT DIGIT 000011B
          LX6    4           ADD TO ASSEMBLY
          BX6    X6+X2
          BX2    -X4*X5      EXTRACT NEXT DIGIT 
          BX5    X4*X5       CLEAR DIGIT
          ZR     X2,HEX4     IF END OF WORD 
          EQ     HEX2        IF NOT END OF WORD 
  
 HEX4     BX4    X4-X4       RETURN NO ERROR
          EQ     CVTHEX 
          EJECT 
 FINDOCT  TITLE  FINDOCT - CONVERT THE OCTAL VALUE TO DISPLAY CODE. 
**        FINDOCT - CONVERT THE OCTAL VALUE TO DISPLAY CODE.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         FINDOCT - DETERMINE IF THE DISPLAY CODE CHARACTERS IN 
*         REGISTER X3 IS AN OCTAL NUMBER. BLANKS ARE IGNORED. 
* 
*         ENTRY 
* 
*           X3 = DISPLAY CODE OF VALUE LEFT JUSTIFIED 
* 
*         EXIT
* 
*           X5 = CONVERTED OCTAL VALUE RIGHT JUSTIFIED.  IF THE VALUE 
*                IS NOT OCTAL, X5 IS SET NEGATIVE. X3 IS NOT DISTURBED. 
* 
*         ROUTINES CALLED -  CVTHEX - CONVERT HEXADECIMAL DISPLAY 
*                                     CODE TO BINARY WHEN COMPILING 
*                                     A 16-BIT MODULE.
*                            CVTHXB - CONVERT HEXADECIMAL DISPLAY 
*                                     CODE TO BINARY WHEN COMPILING 
*                                     A 16-BIT MODULE. H RADIX IS 
*                                     REQUIRED. 
*                            CVTINT - CONVERT DISPLAY CODE TO BINARY. 
*                            SVREG  - SAVE/RESTORE X,B REGISTERS. 
* 
*         DATA AREAS USED -  FOCB   - BUFFER FOR REGISTER A3. 
*                            FOCA   - RESULT BUFFER.
* 
*         USES   A - 1, 3, 5, 6, 7. 
*                X - 1, 3, 5, 6, 7. 
*                B - 1, 6, 7. 
* 
  
 FINDOCT  DATA   0           ENTRY/EXIT 
          BX5    X7          SAVE X7
          SX7    A3 
          SA7    FOCB        SAVE A3
          BX7    X5          RESTORE X7 
          SB1    B0 
          RJ     SVREG       SAVE REGISTERS 
          SA1    BASE 
          BX5    X3          NUMBER TO CONVERT
          SB7    X1          BASE 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,FOC3     IF NOT 16-BIT
          SB6    2           CODE FOR BASE HEX
          NE     B7,B6,FOC3  IF NOT BASE HEX
          RJ     CVTHEX      CONVERT HEX TO BINARY
          ZR     X4,FOC1     IF NO ERROR ON CONVERSION
          EQ     FOC4        CHECK FOR EQUATED VALUE
 FOC3     RJ     CVTINT      CONVERT WORD TO BINARY 
          ZR     X4,FOC1     IF NO ERROR ON CONVERSION
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,FOC4     IF NOT 16-BIT
          SA3    FOCB        GET X3 
          SA3    X3          RESTORE X3 
          BX5    X3          RESTORE WORD TO CONVERT
          RJ     CVTHXB      CONVERT HEX WORD TO BINARY 
          ZR     X4,FOC1     IF NO ERROR ON CONVERSION
 FOC4     SA2    PEQUATE
          SA3    FOCB 
          SA3    X3 
          RJ     SCAN 
          SX6    X5 
          PL     B4,FOC0           IF EQUATE VALUE FOUND
          MX6    1           SET RESULT NEGATIVE
          EQ     FOC1 
 FOC0     SA6    FOCA 
          IFEQ   CMSE,0,1 
          RJ     CXREF
          EQ     FOC2 
 FOC1     SA6    FOCA        SAVE RESULT
 FOC2     RJ     SVREG             RESTORE REGISTERS
          SA3    FOCB 
          SA3    X3          RESTORE A3/X3
          SA5    FOCA        GET RESULT 
          EQ     FINDOCT     EXIT 
  
 FOCA     DATA   0           RESULT BUFFER
 FOCB     DATA   0           BUFFER FOR A3 REGISTER 
          EJECT 
 SCAN     TITLE  SCAN - SCAN TABLE OF DATA FOR MATCH. 
**        SCAN - SCAN TABLE OF DATA FOR MATCH.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         SCAN - SCAN A TABLE OF DATA ITEMS TO DETERMINE IF A MATCH 
*         CAN BE FOUND BETWEEN THE TABLE AND A SUPPLIED DATA ITEM.
* 
*         ENTRY -   X2 = SCAN CONTROL WORD
* 
*                        BITS  0 - 17 = POINTER TO TABLE TO SCAN
*                        BITS 18 - 23 = NUMBER OF ITEMS TO SCAN 
*                   X3 = ITEM TO SCAN FOR 
* 
* 
*         EXIT  -   B4 = INDEX TO THE TABLE WHERE THE FIND WAS MADE.
*                   IF NOT FOUND, B4 IS SET NEGATIVE. 
*                   X5 = ITEM FOUND 
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  (X2) USED TO SPECIFY DATA AREA USED. 
* 
*         USES   A - 5. 
*                X - 2, 5, 6. 
*                B - 2, 3, 4. 
* 
  
 SCAN     DATA   0           ENTRY/EXIT 
          SB2    X2          FWA OF TABLE TO SEARCH 
          AX2    18 
          SB3    X2          LENGTH OF TABLE TO SCAN
          SB4    B0          INDEX OF FIND
          MX2    42 
 SCAN1    SA5    B2+B4       READ WORD FROM TABLE 
          BX6    X5*X2       MASK KEYWORD 
          BX6    X6-X3
          ZR     X6,SCAN     EXIT IF FOUND
          SB4    B4+B1       ADVANCE INDEX
          NE     B3,B4,SCAN1 IF ALL WORDS NOT SEARCHED
          SB4    400000B     INDICATE FIND NOT MADE 
          EQ     SCAN        EXIT 
          EJECT 
 CADD     TITLE  CADD - GENERATE PPU CODE FOR ADD INSTRUCTIONS. 
**        CADD - GENERATE PPU CODE FOR ADD INSTRUCTIONS.
* 
*         K.B. SMITH. 78/05/09
* 
*         CADD - GENERATE PPU CODE THAT PERFORMS ONE OF THE FOL-
*         LOWING ADD OPERATIONS, AND ADD IT TO THE X0 REGISTER. NO
*         CODE IS GENERATED IF IT WOULD RESULT IN ADN 0.
* 
*                ADN VALUE                ADM BUFFER
*                ADC VALUE                ADM BUFFER + VALUE
*                ADD REGISTER             ADM BUFFER(REGISTER)
* 
*          ENTRY-  B2 = DESCRIPTOR FOR THE CONTENTS OF B3 AND X2
* 
*                     0 = BUFFER(REGISTER)
*                     1 = BUFFER OR BUFFER(VALUE) 
*                     2 = REGISTER
*                     3 = VALUE 
*                  B3 = REGISTER VALUE IN BITS 0-5(00 IF NOT REGISTER ) 
*                  B6 = RETURN ADDRESS
*                  X2 = BUFFER ADDRESS OR VALUE IN BITS 0-11. REGISTER
*                       VALUE OR 00 IN BITS 12 - 17.
* 
*         EXIT - BINARY CODE ADDED TO THE ORIGINAL CONTENTS OF X0. (X0
*                IS LEFT SHIFTED AND BYTES ARE ADDED TO LOWER BYTES)
* 
*         ROUTINES CALLED - CSTOREB 
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - NONE.
*                X - 0, 6, 7. 
*                B - 4. 
* 
  
 CADD     RJ     CSTOREB     STORE CODE IN X0 
          ZR     B2,CAD4     IF BUFFER(REGISTER)
          EQ     B2,B1,CAD5  IF BUFFER
          SB4    B2-B1
          EQ     B4,B1,CAD2  IF REGISTER
          ZR     X2,CAD8     IF ADN 0 - GENERATE NO CODE
          MX7    -6 
          BX7    X7*X2
          NZ     X7,CAD1     IF VALUE GREATER THAN 6 BITS 
          SX0    X2+ADN      CODE = ADN VALUE 
          EQ     CAD7 
 CAD1     SX0    ADC
          LX0    12 
          BX0    X0+X2       CODE = ADC VALUE 
          EQ     CAD7 
 CAD2     SX7    B3-100B
          PL     X7,CAD3     IF NON-DIRECT REGISTER 
          SX0    ADD+B3      CODE = ADD REGISTER
          EQ     CAD7 
 CAD3     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16AD3   IF 16 BIT
          SX0    ADM
          SX7    B3 
          LX0    12 
          BX0    X0+X7       CODE = ADM REGISTER
          EQ     CAD7 
 C16AD3   SX0    ADM
          SX7    B3 
          LX0    24 
          BX0    X0+X7       CODE = ADM REGISTER
          EQ     CAD7 
 CAD4     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16AD4   IF 16 BIT
          SX7    B3-100B
          PL     X7,CAD6     IF NON-DIRECT REGISTER 
 CAD5     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16AD5   IF 16 BIT
          SX0    ADM
          LX0    12 
          BX0    X0+X2       CODE = ADM BUFFER(REGISTER)
          EQ     CAD7 
 C16AD4   SX7    B3-100B
          PL     X7,C16AD6   IF NON-DIRECT REGISTER 
          MX7    6           SET MASK 
          LX7    24          SET MASK FOR REGISTER VALUE
          BX0    X2*X7       EXTRACT REGISTER VALUE 
          LX0    6           POSITION REGISTER VALUE
          MX7    -18         SET MASK FOR 16 BIT ADDRESS
          BX2    -X7*X2      CLEAR ALL OTHER BITS 
          BX2    X2+X0       RESTORE X2 WITH SHIFTED VALUE
 C16AD5   SX0    ADM
          LX0    24 
          BX0    X0+X2       CODE = ADM BUFFER(REGISTER)
          EQ     CAD7 
 C16AD6   SX0    STD+YREG    CODE = STD YREG
          LX0    12 
          SX7    LDM
          BX0    X0+X7
          LX0    24 
          SX7    B3 
          BX0    X0+X7       LDM REGISTER 
          LX0    24 
          SX7    STD+XREG           STD XREG
          BX0    X0+X7
          RJ     CSTOREB
          SX0    LDD+YREG           LDD YREG
          LX0    24 
          SX7    ADM+XREG 
          BX0    X0+X7
          LX0    24 
          MX7    -24
          BX7    -X7*X2 
          BX0    X0+X7              ADM BUFFER(XREG)
          EQ     CAD7 
 CAD6     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16AD6   IF 16 BIT
          SX0    STD+YREG    CODE = STD YREG
          LX0    12 
          SX7    LDM
          BX0    X0+X7
          LX0    12 
          SX7    B3 
          BX0    X0+X7       LDM REGISTER 
          LX0    12 
          SX7    STD+XREG           STD XREG
          BX0    X0+X7
          RJ     CSTOREB
          SX0    LDD+YREG           LDD YREG
          LX0    12 
          SX7    ADM+XREG 
          BX0    X0+X7
          LX0    12 
          MX7    -12
          BX7    -X7*X2 
          BX0    X0+X7              ADM BUFFER(XREG)
 CAD7     RJ     CSTOREB
 CAD8     JP     B6          EXIT 
          EJECT 
*                  IF 16 BIT
*                  X2 = BUFFER ADDRESS OR VALUE IN BITS 0-17. REGISTER
*                       VALUE OR 00 IN BITS 18 - 23.
* 
 CAND     TITLE  CAND -GENERATE PPU CODE LOGICAL PRODUCT OPERATIONS.
**        CAND -GENERATE PPU CODE LOGICAL PRODUCT OPERATIONS. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*           CAND- GENERATE PPU CODE THAT PERFORMS ONE OF THE
*           FOLLOWING LOGICAL PRODUCT OPERATIONS, AND ADD IT TO THE 
*           X0 REGISTER.
* 
*             1. LPN VALUE
*             2. LPC VALUE
*             3. STD PA        LDD REG               RJM AND
*                          OR  LDM BUFFER 
*                          OR  LDM BUFFER + OCTAL 
*         ENTRY            OR  LDM BUFFER ( REGISTER) 
* 
*           B2 = DESCRIPTOR FOR THE CONTENTS OF B3 AND X2 
*                0 = BUFFER(REGISTER) 
*                1 = BUFFER OR BUFFER(VALUE)
*                2 = REGISTER 
*                3 = VALUE
*           B3 = REGISTER VALUE IN BITS 0-5 ( 00 IF NOT A REGISTER )
*           B6 = RETURN ADDRESS 
*           X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 11.  REGISTER
*                VALUE OR 00 IN BITS 12 - 17. 
*         EXIT
* 
*           BINARY CODE ADDED TO THE ORIGINAL CONTENTS OF X0. (X0 IS
*           LEFT SHIFTED AND BYTES ARE ADDED TO THE LOWER BYTES)
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  RJMAND - PPU CODE FOR RJM TO AND.
* 
*         USES   A - 1. 
*                X - 0, 1, 6. 
*                B - 4. 
* 
  
 CAND     SB4    B2-3 
          ZR     B4,CAN1     IF OCTAL 
          SX1    STD+PA      CODE = STD PA
          LX0    12          PREPARE TO RECEIVE ONE BYTE
          BX0    X0+X1
          RJ     CLOAD       GENERTE LOAD CODE
          SA1    RJMAND      CODE = RJM ADD 
          BX0    X1 
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          JP     B6          EXIT 
 CAN1     SX6    X2-100B
          PL     X6,CAN2     IF VALUE GREATER THAN 6 BITS 
          LX0    12          PREPARE TO RECEIVE ONE BYTE
          SX1    X2+LPN      CODE = LPN VALUE 
          BX0    X0+X1
          JP     B6          EXIT 
 CAN2     LX0    24          PREPARE TO RECEIVE TWO BYTES 
          SX1    LPC
          LX1    12 
          BX1    X1+X2       CODE = LPC VALUE 
          BX0    X0+X1
          JP     B6          EXIT 
 RJMAND   VFD    36/0,12/RJM,12/AND 
          EJECT 
 CEQ      TITLE  CEQ - GENERATE JUMP CODE FOR THE EQUAL JUMP TEST.
**        CEQ - GENERATE JUMP CODE FOR THE EQUAL JUMP TEST. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*           CEQ - GENERATE JUMP CODE FOR THE EQUAL JUMP TEST. 
* 
*                CODE =  NJN (X7) 
* 
*         ENTRY     B6 = RETURN ADDRESS 
*                   X7 = NUMBER OF BYTES TO JUMP OVER 
* 
*         EXIT      JUMP CODE ADDED TO X0 REGISTER
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - N0NE.
*                X - 0, 7.
*                B - NONE.
* 
  
 CEQ      LX0    12          PREPARE WORD FOR JUMP INSTRUCTION
          SX7    X7+NJN 
          BX0    X0+X7
          JP     B6          EXIT 
          EJECT 
 CGE      TITLE  CGE - GENERATE PPU CODE FOR THE .GT. OR .EQ. 
**        CGE - GENERATE PPU CODE FOR THE .GT. OR .EQ.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*          CGE - GENERATE JUMP CODE FOR THE GREATER THAN OR EQUAL TEST. 
* 
*                CODE = MJN (X7)
* 
*         ENTRY    B6 = RETURN ADDRESS
*                  X7 = NUMBER OF BYTES TO JUMP OVER
* 
*         EXIT     JUMP CODE ADDED TO X0 REGISTER 
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - N0NE.
*                X - 0, 7.
*                B - NONE.
* 
 CGE      LX0    12          PREPARE WORD FOR JUMP INSTRUCTION
          SX7    X7+MJN 
          BX0    X0+X7
          JP     B6          EXIT 
          EJECT 
 CGT      TITLE  CGT - GENERATE PPU CODE FOR .GT. 
**        CGT - GENERATE PPU CODE FOR .GT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*           CGT - GENERATE JUMP CODE FOR THE GREATER THAN JUMP TEST.
* 
*                CODE = SBN 1 
*                       MJN (X7)
* 
*         ENTRY     B6 = RETURN ADDRESS 
*                   X7 = NUMBER OF BYTES TO JUMP OVER 
* 
* 
*         EXIT      JUMP CODE ADDED TO X0 REGISTER
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - N0NE.
*                X - 0, 6, 7. 
*                B - NONE.
* 
  
 CGT      LX0    12          PREPARE WORD FOR FIRST INSTRUCTION 
          SX6    SBN+1
          BX0    X0+X6
          SX7    X7+MJN 
          LX0    12          PREPARE WORD FOR SECOND INSTRUCTION
          BX0    X0+X7
          JP     B6          EXIT 
          EJECT 
 CLE      TITLE  CLE - GENERATE PPU CODE FOR .LE. 
**        CLE - GENERATE PPU CODE FOR .LE.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*           CLE - GENERATE JUMP CODE FOR THE LESS THAN OR EQUAL TEST. 
* 
*                CODE = ZJN +2
*                       PJN (X7)
* 
*         ENTRY     B6 = RETURN ADDRESS 
*                   X7 = NUMBER OF BYTES TO JUMP OVER 
* 
* 
*         EXIT     JUMP CODE ADDED TO X0 REGISTER 
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - N0NE.
*                X - 0, 6, 7. 
*                B - NONE.
* 
  
 CLE      LX0    12          PREPARE WORD FOR FIRST INSTRUCTION 
          SX6    ZJN+2
          BX0    X0+X6
          SX7    X7+PJN 
          LX0    12          PREPARE WORD FOR SECOND INSTRUCTION
          BX0    X0+X7
          JP     B6          EXIT 
          EJECT 
 CLOAD    TITLE  CLOAD - GENERATE PPU CODE FOR A LOAD INSTRUCTION.
**        CLOAD - GENERATE PPU CODE FOR A LOAD INSTRUCTION. 
* 
*         K.B.SMITH. 78/05/09.
* 
*           CLOAD - GENERATE PPU CODE THAT PERFORMS ONE OF THE
*           FOLLOWING LOAD OPERATIONS, AND ADD IT TO X0 REGISTER. 
* 
*                 LDN VALUE            LDM BUFFER 
*                 LDC VALUE            LDM BUFFER + VALUE 
*                 LDD REGISTER         LDM BUFFER (REGISTER)
*                 IAN 14B 
*                LDN LINE NUMBER
*                LDC LINE NUMBER
* 
*         ENTRY 
* 
*           B2 = DESCRIPTOR FOR THE CONTENTS OF B3 AND X2 
* 
*                0 = BUFFER(REGISTER) 
*                1 = BUFFER OR BUFFER(VALUE)
*                2 = REGISTER 
*                3 = VALUE
*           B3 = REGISTER VALUE IN BITS 0 - 5 (00 IF NOT A REGISTER ) 
*           X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 11, REGISTER OR
*                00 IN BITS 12 - 17.
*           IF 16 BIT 
*           X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 17, REGISTER OR
*                00 IN BITS 18 - 23.
* 
* 
*         EXIT -  BINARY CODE ADDED TO THE ORIGINAL CONTENTS OF X0
*                 (X0 IS LEFT SHIFTED AND THE BYTES CREATED ARE ADDED 
*                 TO THE LOWER BYTE POSITION. 
* 
*         ROUTINES CALLED - CSTOREB 
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - .
*                X - 0,1,6,7. 
*                B - 4. 
* 
  
 CLOAD    DATA   0           ENTRY/EXIT 
          RJ     CSTOREB
          ZR     B2,CLD5     IF BUFFER(REGISTER)
          EQ     B2,B1,CLD6  IF BUFFER
          SB4    B2-B1
          EQ     B4,B1,CLD2  IF REGISTER
          MX7    -6 
          BX7    X7*X2
          NZ     X7,CLD1     IF VALUE GREATER THAN 6 BITS 
          SX0    X2+LDN      CODE = LDN VALUE 
          EQ     CLD8 
 CLD1     SX0    LDC
          LX0    12 
          BX0    X0+X2       CODE = LDC VALUE 
          EQ     CLD8 
 CLD2     SX7    B3-RT
          NZ     X7,CLD3     IF NOT REAL TIME CLOCK 
          SX0    IANCLK      CODE = IAN CLK 
          EQ     CLD8 
 CLD3     SX7    X7+RT-P
          NZ     X7,CLD4A    IF NOT P REGISTER
          SA1    PLINES 
          SX7    LINES
          IX1    X1-X7             CALCULATE LINE NUMBER
          SX7    X1-100B
          PL     X7,CLD4     IF GREATER THAN 6 BITS 
          SX0    X1+LDN      CODE = LDN LINE NUMBER 
          EQ     CLD8 
 CLD4     SX0    LDC
          LX0    12 
          BX0    X0+X1       CODE = LDC LINE NUMBER 
          EQ     CLD8 
 CLD4A    SX7    X7+P-100B
          PL     X7,CLD4B    IF NON-DIRECT REGISTER 
          SX0    B3+LDD      CODE = LDD REGISTER
          EQ     CLD8 
 CLD4B    SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,CL16D4B  IF 16 BIT SET
          SX0    LDM
          LX0    12 
          SX7    B3 
          BX0    X0+X7       CODE = LDM REGISTER
          EQ     CLD8 
 CL16D4B  SX0    LDM
          LX0    24 
          SX7    B3 
          BX0    X0+X7       CODE = LDM REGISTER
          EQ     CLD8 
 CLD5     SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,CL16D5   IF 16 BIT SET
          SX7    B3-100B
          PL     X7,CLD7     IF NON-DIRECT REGISTER 
 CLD6     SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,CL16D6   IF 16 BIT SET
          SX0    LDM
          LX0    12 
          BX0    X0+X2       CODE = LDM BUFFER(REGISTER)
          EQ     CLD8 
 CL16D5   SX7    B3-100B
          PL     X7,CL16D7   IF NON-DIRECT REGISTER 
          MX7    6           SET MASK 
          LX7    24          SET MASK FOR REGISTER VALUE
          BX0    X2*X7       EXTRACT REGISTER VALUE 
          LX0    6           POSITION REGISTER VALUE
          MX7    -18         SET MASK FOR 16 BIT ADDRESS
          BX2    -X7*X2      CLEAR ALL OTHER BITS 
          BX2    X2+X0       RESTORE X2 WITH SHIFTED VALUE
 CL16D6   SX0    LDM
          LX0    24 
          BX0    X0+X2       CODE = LDM BUFFER(REGISTER)
          EQ     CLD8 
 CL16D7   SX0    LDM
          LX0    24 
          SX7    B3 
          BX0    X0+X7       CODE = LDM REGISTER
          LX0    24 
          SX7    STD+XREG 
          BX0    X0+X7              STD XREG
          LX0    24 
          SX7    LDM+XREG 
          BX0    X0+X7
          LX0    24 
          MX7    -24
          BX7    -X7*X2 
          BX0    X0+X7       LDM BUFFER(XREG) 
          EQ     CLD8 
 CLD7     SX0    LDM
          LX0    12 
          SX7    B3 
          BX0    X0+X7       CODE = LDM REGISTER
          LX0    12 
          SX7    STD+XREG 
          BX0    X0+X7              STD XREG
          LX0    12 
          SX7    LDM+XREG 
          BX0    X0+X7
          LX0    12 
          MX7    -12
          BX7    -X7*X2 
          BX0    X0+X7       LDM BUFFER(XREG) 
 CLD8     RJ     CSTOREB     STORE CODE 
          EQ     CLOAD       EXIT 
          EJECT 
 CLOADC   TITLE  CLOADC - GENERATE PPU CODE FOR A LOAD INSTRUCTION. 
**        CLOADC - GENERATE PPU CODE FOR A LOAD INSTRUCTION.
* 
*         K.B.SMITH. 78/05/10.
* 
*           CLOADC - GENERATE PPU CODE THAT PERFORMS ONE OF THE 
*           FOLLOWING LOAD OPERATIONS, AND ADD IT TO X0 REGISTER. 
* 
*                 LDN VALUE            LDC BUFFER 
*                 LDC VALUE            LDC BUFFER + VALUE 
*                 LDD REGISTER         LDD REG   ADC BUFFER 
* 
*         ENTRY -   B2 = DESCRIPTOR FOR THE CONTENTS OF B3 AND X2 
* 
*                        0 = BUFFER(REGISTER) 
*                        1 = BUFFER OR BUFFER(VALUE)
*                        2 = REGISTER 
*                        3 = VALUE
*                B3 = REGISTER VALUE IN BITS 0-5(00 IF NOT A REGISTER)
*                X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 11, REGISTER
*                     OR 00 IN BITS 12 - 17.
*                IF 16 BIT
*                X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 17, REGISTER
*                     OR 00 IN BITS 18 - 23.
* 
*         EXIT - BINARY CODE ADDED TO THE ORIGINAL CONTENTS OF X0 
*               (X0 IS LEFT SHIFTED AND THE BYTES CREATED ARE ADDED TO
*                THE   LOWER BYTE POSITION. 
* 
*         ROUTINES CALLED - CSTOREB 
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - N0NE.
*                X - 0, 2, 6, 7.
*                B - 4. 
* 
  
 CLOADC   DATA   0           ENTRY/EXIT 
          RJ     CSTOREB
          SB4    B2-B1
          ZR     B2,CLC1     IF BUFFER(REGISTER)
          EQ     B2,B1,CLC4  IF BUFFER OF BUFFER(VALUE) 
          EQ     B4,B1,CLC1  IF REGISTER
          SX7    X2-100B
          PL     X7,CLC4     IF VALUE MAORE THAN 6 BITS 
          SX0    X2+LDN      CODE = LDN VALUE 
          EQ     CLC5 
 CLC1     SX7    B3-100B
          PL     X7,CLC2     IF NON-DIRECT REGISTER 
          SX0    B3+LDD      CODE = LDD REGISTER
          EQ     CLC3 
 CLC2     SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,CL16C2   IF 16 BIT FLAG 
          SX0    LDM
          LX0    12 
          SX7    B3 
          BX0    X0+X7       CODE = LDM REGISTER
 CLC3     SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,CL16C3   IF 16 BIT FLAG 
          EQ     B4,B1,CLC5  IF REGISTER
          LX0    12 
          SX7    ADC
          BX0    X0+X7
          LX0    12 
          MX7    -12
          BX7    -X7*X2 
          BX0    X0+X7       CODE = ADC BUFFER
          EQ     CLC5 
 CLC4     SX0    LDC
          LX0    12 
          BX0    X0+X2       CODE = LDC VALUE/BUFFER
 CLC5     RJ     CSTOREB     STORE CODE GENERATED 
          EQ     CLOADC      EXIT 
 CL16C2   SX0    LDM
          LX0    24 
          SX7    B3 
          BX0    X0+X7       CODE = LDM REGISTER
 CL16C3   EQ     B4,B1,CLC5  IF REGISTER
          LX0    12 
          SX7    ADC
          BX0    X0+X7
          LX0    12 
          MX7    -13
          BX7    -X7*X2 
          BX0    X0+X7       CODE = ADC BUFFER
          EQ     CLC5 
          EJECT 
 CLS      TITLE  CLS - GENERATE PPU CODE FOR A SHIFT LEFT OPERATION.
**        CLS - GENERATE PPU CODE FOR A SHIFT LEFT OPERATION. 
* 
*         J. E. SIPPER. 76/12/08. 
* 
*           CLS - GENERATE PPU CODE THAT PERFORMS A LEFT SHIFT
*           OPERATION, AND ADD IT TO THE X0 REGISTER. 
* 
*                              LDN VALUE
*                          OR  LDC VALUE
*             STD PA       OR  LDD REG               RJM LS 
*                          OR  LDM BUFFER 
*                          OR  LDM BUFFER + OCTAL 
*                          OR  LDM BUFFER,REGISTER
* 
*         ENTRY 
* 
*           B2 = DESCRIPTOR FOR THE CONTENTS OF B3 AND X2 
* 
*                0 = BUFFER(REGISTER) 
*                1 = BUFFER OR BUFFER(VALUE)
*                2 = REGISTER 
*                3 = VALUE
*           B3 = REGISTER VALUE IN BITS 0-5 ( 00 IF NOT A REGISTER )
*           B6 = RETURN ADDRESS 
*           X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 11.  REGISTER
*                VALUE OR 00 IN BITS 12 - 17. 
* 
*         EXIT
* 
*           BINARY CODE ADDED TO THE ORIGINAL CONTENTS OF X0. (X0 IS
*           LEFT SHIFTED AND BYTES ARE ADDED TO THE LOWER BYTES)
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - 1. 
*                X - 1. 
*                B - NONE.
* 
  
 CLS      SA1    RJMLS
          EQ     COR1 
  
 RJMLS    VFD    36/0,12/RJM,12/LS
          EJECT 
 CLT      TITLE  CLT - GENERATE PPU CODE FOR .LT. 
**        CLT - GENERATE PPU CODE FOR .LT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*           CLT - GENERATE JUMP CODE FOR THE LESS THAN JUMP TEST. 
* 
*                CODE = PJN (X7)
* 
*         ENTRY    (B6) = RETURN ADDRESS
*                  (X7) = NUMBER OF BYTES TO JUMP OVER
* 
*         EXIT     JUMP CODE ADDED TO X0 REGISTER 
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - N0NE.
*                X - 0, 7.
*                B - NONE.
* 
  
 CLT      LX0    12          PREPARE WORD FOR JUMP INSTRUCTION
          SX7    X7+PJN 
          BX0    X0+X7
          JP     B6          EXIT 
          EJECT 
 CMINUS   TITLE  CMINUS - GENERATE PPU CODE FOR SUBTRACT. 
**        CMINUS - GENERATE PPU CODE FOR SUBTRACT.
* 
*         K.B.SMITH. 78/05/10.
* 
*           CMINUS - GENERATE PPU CODE THAT PERFORMS ONE OF THE 
*           SUBTRACT OPERATIONS BELOW, AND ADD IT TO THE X0 REGISTER. 
*           NO CODE IS GENERATED IF IT WOULD RESULT IN SBN 0. 
* 
*                SBN VALUE               SBM BUFFER 
*                ADC -VALUE              SBM BUFFER + VALUE 
*                SBD REGISTER            SBM BUFFER,REGISTER
*        ENTRY
* 
*           B2 = DESCRIPTOR FOR THE CONTENTS OF B3 AND X2 
*                0 = BUFFER(REGISTER) 
*                1 = BUFFER OR BUFFER(VALUE)
*                2 = REGISTER 
*                3 = VALUE
*           B3 = REGISTER VALUE IN BITS 0-5 ( 00 IF NOT A REGISTER )
*           B6 = RETURN ADDRESS 
*           X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 11.  REGISTER
*                VALUE OR 00 IN BITS 12 - 17. 
*           IF 16 BIT 
*           X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 17.  REGISTER
*                VALUE OR 00 IN BITS 18 - 23. 
*         EXIT
* 
*           BINARY CODE ADDED TO THE ORIGINAL CONTENTS OF X0. (X0 IS
*           LEFT SHIFTED AND BYTES ARE ADDED TO THE LOWER BYTES)
* 
*         ROUTINES CALLED - CSTOREB 
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - NONE.
*                X - 0, 2, 6, 7.
*                B - 4. 
* 
 CMINUS   RJ     CSTOREB
          ZR     B2,CMI4     IF BUFFER(REGISTER)
          EQ     B2,B1,CMI5  IF BUFFER(VALUE) 
          SB4    B2-B1
          EQ     B4,B1,CMI2  IF REGISTER
          ZR     X2,CMI8     NO CODE IF VALUE = 0 
          SX7    X2-100B
          PL     X7,CMI1     IF VALUE GREATER THAN 6 BITS 
          SX0    X2+SBN      CODE = SBN VALUE 
          EQ     CMI7 
 CMI1     SX0    ADC
          LX0    12 
          MX7    -18
          BX7    -X7-X2 
          BX0    X0+X7       CODE = ADC -VALUE
          EQ     CMI7 
 CMI2     SX7    B3-100B
          PL     X7,CMI3     IF NON-DIRECT REGISTER 
          SX0    B3+SBD      CODE = SBD REGISTER
          EQ     CMI7 
 CMI3     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16MI3   IF 16 BIT
          SX0    SBM
          LX0    12 
          SX7    B3 
          BX0    X0+X7       CODE = SBM REGISTER
          EQ     CMI7 
 C16MI3   SX0    SBM
          LX0    24 
          SX7    B3 
          BX0    X0+X7       CODE = SBM REGISTER
          EQ     CMI7 
 CMI4     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16MI4   IF 16 BIT
          SX7    B3-100B
          PL     X7,CMI6     IF NON-DIRECT REGISTER 
 CMI5     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16MI5   IF 16 BIT
          SX0    SBM
          LX0    12 
          BX0    X0+X2       CODE = SBM BUFFER(REGISTER)
          EQ     CMI7 
 C16MI4   SX7    B3-100B
          PL     X7,C16MI6   IF NON-DIRECT REGISTER 
          MX7    6           SET MASK 
          LX7    24          SET MASK FOR REGISTER VALUE
          BX0    X2*X7       EXTRACT REGISTER VALUE 
          LX0    6           POSITION REGISTER VALUE
          MX7    -18         SET MASK FOR 16 BIT ADDRESS
          BX2    -X7*X2      CLEAR ALL OTHER BITS 
          BX2    X2+X0       RESTORE X2 WITH SHIFTED VALUE
 C16MI5   SX0    SBM
          LX0    24 
          BX0    X0+X2       CODE = SBM BUFFER(REGISTER)
          EQ     CMI7 
 C16MI6   SX0    STD+YREG    CODE = STD YREG
          LX0    12 
          SX7    LDM
          BX0    X0+X7
          LX0    12 
          SX7    B3 
          BX0    X0+X7             LDM REGISTER 
          LX0    12 
          SX7    STD+XREG 
          BX0    X0+X7              STD XREG
          RJ     CSTOREB
          SX0    LDD+YREG           LDD YREG
          LX0    12 
          SX7    SBM+XREG 
          BX0    X0+X7
          LX0    24 
          MX7    -24
          BX7    -X7*X2 
          BX0    X0+X7              SBM BUFFER(XREG)
          EQ     CMI7        STORE CODE 
 CMI6     SX0    STD+YREG    CODE = STD YREG
          LX0    12 
          SX7    LDM
          BX0    X0+X7
          LX0    12 
          SX7    B3 
          BX0    X0+X7             LDM REGISTER 
          LX0    12 
          SX7    STD+XREG 
          BX0    X0+X7              STD XREG
          RJ     CSTOREB
          SX0    LDD+YREG           LDD YREG
          LX0    12 
          SX7    SBM+XREG 
          BX0    X0+X7
          LX0    12 
          MX7    -12
          BX7    -X7*X2 
          BX0    X0+X7              SBM BUFFER(XREG)
 CMI7     RJ     CSTOREB     STORE CODE 
 CMI8     JP     B6          EXIT 
          EJECT 
 CNE      TITLE  CNE - GENERATE PPU CODE FOR .NE. 
**        CNE - GENERATE PPU CODE FOR .NE.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*           CNE - GENERATE JUMP CODE FOR THE NOT EQUAL JUMP TEST. 
* 
*                CODE = ZJN (X7)
* 
*         ENTRY    B6 = RETURN ADDRESS
*                  X7 = NUMBER OF BYTES TO JUMP OVER
* 
*         EXIT    JUMP CODE ADDED TO X0 REGISTER
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - N0NE.
*                X - 0, 7.
*                B - NONE.
* 
 CNE      LX0    12          PREPARE WORD FOR JUMP INSTRUCTION
          SX7    X7+ZJN 
          BX0    X0+X7
          JP     B6          EXIT 
          EJECT 
 COR      TITLE  COR - GENERATE PPU CODE FOR .OR. 
**        COR - GENERATE PPU CODE FOR .OR.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*           COR - GENERATE PPU CODE THAT PERFORMS A LOGICAL OR
*           OPERATION, AND ADD IT TO THE X0 REGISTER. 
* 
*                              LDN VALUE
*                          OR  LDC VALUE
*             STD PA       OR  LDD REG               RJM OR 
*                          OR  LDM BUFFER 
*                          OR  LDM BUFFER + OCTAL 
*                          OR  LDM BUFFER,REGISTER
* 
*         ENTRY 
* 
*           B2 = DESCRIPTOR FOR THE CONTENTS OF B3 AND X2 
* 
*                0 = BUFFER(REGISTER) 
*                1 = BUFFER OR BUFFER(VALUE)
*                2 = REGISTER 
*                3 = VALUE
*           B3 = REGISTER VALUE IN BITS 0-5 ( 00 IF NOT A REGISTER )
*           B6 = RETURN ADDRESS 
*           X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 11.  REGISTER
*                VALUE OR 00 IN BITS 12 - 17. 
*         EXIT
* 
*           BINARY CODE ADDED TO THE ORIGINAL CONTENTS OF X0. (X0 IS
*           LEFT SHIFTED AND BYTES ARE ADDED TO THE LOWER BYTES)
* 
*         ROUTINES CALLED -  NONE 
* 
*         DATA AREAS USED -  RJMOR. 
* 
*         USES   A - 1. 
*                X - 0, 1, 7. 
*                B - NONE.
* 
  
 COR      SA1    RJMOR
 COR1     BX7    X1          SAVE RTJ CODE
          SA7    CORA 
          SX1    STD+PA      CODE = STD PA
          LX0    12          PREPARE TO RECEIVE ONE BYTE
          BX0    X0+X1
          BX1    X7          RESTORE RTJ CODE 
          RJ     CLOAD       GENERATE LOAD CODE 
          SA1    CORA 
          BX0    X1          CODE = RTJ LS/RL/OR
          RJ     CABSPPU    ABSOLUTIZE PPU ADDRESSES
          JP     B6          EXIT 
  
 RJMOR    VFD    36/0,12/RJM,12/OR
 CORA     BSS    1
          EJECT 
 CRS      TITLE  CRS - GENERATE PPU CODE FOR A RIGHT SHIFT. 
**        CRS - GENERATE PPU CODE FOR A RIGHT SHIFT.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*           CRS - GENERATE PPU CODE THAT PERFORMS A RIGHT SHIFT 
*           OPERATION, AND ADD IT TO THE X0 REGISTER. 
* 
*             SHN - VALUE (IF A CONSTANT IS SPECIFIED)
*                          OTHERWISE, ONE OF THE FOLLOWING
* 
*             STD PA       OR  LDD REG               RJM RS 
*                          OR  LDM BUFFER 
*                          OR  LDM BUFFER + OCTAL 
*                          OR  LDM BUFFER,REGISTER
* 
*         ENTRY 
* 
*           B2 = DESCRIPTOR FOR THE CONTENTS OF B3 AND X2 
* 
*                0 = BUFFER(REGISTER) 
*                1 = BUFFER OR BUFFER(VALUE)
*                2 = REGISTER 
*                3 = VALUE
*           B3 = REGISTER VALUE IN BITS 0-5 ( 00 IF NOT A REGISTER )
*           B6 = RETURN ADDRESS 
*           X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 11.  REGISTER
*                VALUE OR 00 IN BITS 12 - 17. 
* 
*         EXIT
* 
*           BINARY CODE ADDED TO THE ORIGINAL CONTENTS OF X0. (X0 IS
*           LEFT SHIFTED AND BYTES ARE ADDED TO THE LOWER BYTES)
* 
*         ROUTINES CALLED -  NONE.
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - 1. 
*                X - 1. 
*                B - NONE.
* 
  
 CRS      SX1    B2-3 
          NZ     X1,CRS1     IF NOT A VALUE 
          SX1    37B
          BX1    -X2*X1 
          SX0    X1+SHN+40B  FORM RIGHT SHIFT INSTRUCTION 
          JP     B6          EXIT 
  
 CRS1     SA1    RJMRS
          EQ     COR1 
  
 RJMRS    VFD    36/0,12/RJM,12/RS
          EJECT 
 CXOR     TITLE  CXOR - GENERATE PPU CODE FOR EXCLUSIVE OR. 
**        CXOR - GENERATE PPU CODE FOR EXCLUSIVE OR.
* 
*         K.B.SMITH. 78/05/10.
* 
*           CXOR- GENERATE PPU CODE THAT PERFORMS ONE OF THE
*           FOLLOWING EXCLUSIVE OR (LOGICAL DIFFERENCE) OPERATIONS
*           AND ADD IT TO THE X0 REGISTER.
* 
*                LMN VALUE               LMM BUFFER 
*                LMC VALUE               LMM BUFFER + VALUE 
*                LMD REGISTER            LMM BUFFER,REGISTER
*         ENTRY 
* 
*           B2 = DESCRIPTOR FOR THE CONTENTS OF B3 AND X2 
* 
*                0 = BUFFER(REGISTER) 
*                1 = BUFFER OR BUFFER(VALUE)
*                2 = REGISTER 
*                3 = VALUE
*           B3 = REGISTER VALUE IN BITS 0-5 ( 00 IF NOT A REGISTER )
*           B6 = RETURN ADDRESS 
*           X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 11.  REGISTER
*                VALUE OR 00 IN BITS 12 - 17. 
* 
*           IF 16 BIT 
*           X2 = BUFFER ADDRESS OR VALUE IN BITS 0 - 17.  REGISTER
*                VALUE OR 00 IN BITS 18 - 23. 
* 
*         EXIT
* 
*           BINARY CODE ADDED TO THE ORIGINAL CONTENTS OF X0. (X0 IS
*           LEFT SHIFTED AND BYTES ARE ADDED TO THE LOWER BYTES)
* 
*         ROUTINES CALLED - CSTOREB 
* 
*         DATA AREAS USED -  NONE.
* 
*         USES   A - NONE.
*                X - 0, 6, 7. 
*                B - 4. 
 CXOR     RJ     CSTOREB
          ZR     B2,CXR4     IF BUFFER(REGISTER)
          EQ     B2,B1,CXR5  IF BUFFER(VALUE) 
          SB4    B2-B1
          EQ     B4,B1,CXR2  IF REGISTER
          SX7    X2-100B
          PL     X7,CXR1     IF VALUE GREATER THAN 6 BITS 
          SX0    X2+LMN      CODE = LMN VALUE 
          EQ     CXR7 
 CXR1     SX0    LMC
          LX0    12 
          BX0    X0+X2       CODE = LMC VALUE 
          EQ     CXR7 
 CXR2     SX7    B3-100B
          PL     X7,CXR3     IF NON-DIRECT REGISTER 
          SX0    B3+LMD      CODE = LMD REGISTER
          EQ     CXR7 
 CXR3     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16XR3   IF 16 BIT
          SX0    LMM
          LX0    12 
          SX7    B3 
          BX0    X0+X7       CODE = LMM REGISTER
          EQ     CXR7 
 C16XR3   SX0    LMM
          LX0    24 
          SX7    B3 
          BX0    X0+X7       CODE = LMM REGISTER
          EQ     CXR7 
 CXR4     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16XR4   IF 16 BIT
          SX7    B3-100B
          PL     X7,CXR6     IF NON-DIRECT REGISTER 
 CXR5     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16XR5   IF 16 BIT
          SX0    LMM
          LX0    12 
          BX0    X0+X2       CODE = LMM BUFFER(REGISTER)
          EQ     CXR7 
 C16XR4   SX7    B3-100B
          PL     X7,C16XR6   IF NON-DIRECT REGISTER 
          MX7    6           SET MASK 
          LX7    24          SET MASK FOR REGISTER VALUE
          BX0    X2*X7       EXTRACT REGISTER VALUE 
          LX0    6           POSITION REGISTER VALUE
          MX7    -18         SET MASK FOR 16 BIT ADDRESS
          BX2    -X7*X2      CLEAR ALL OTHER BITS 
          BX2    X2+X0       RESTORE X2 WITH SHIFTED VALUE
 C16XR5   SX0    LMM
          LX0    24 
          BX0    X0+X2       CODE = LMM BUFFER(REGISTER)
          EQ     CXR7 
 C16XR6   SX0    STD+YREG    CODE = STD YREG
          LX0    12 
          SX7    LDM
          BX0    X0+X7
          LX0    24 
          SX7    B3 
          BX0    X0+X7              LDM REGISTER
          LX0    12 
          SX7    STD+XREG 
          BX0    X0+X7              STD XREG
          RJ     CSTOREB
          SX0    LDD+YREG           LDD YREG
          LX0    12 
          SX7    LMM+XREG 
          BX0    X0+X7
          LX0    24 
          MX7    -24
          BX7    -X7*X2 
          BX0    X0+X7              LMM BUFFER(XREG)
          EQ     CXR7        STORE CODE 
 CXR6     SA1    F16BIT      CHECK FOR 16 BIT 
          NZ     X1,C16XR6   IF 16 BIT
          SX0    STD+YREG    CODE = STD YREG
          LX0    12 
          SX7    LDM
          BX0    X0+X7
          LX0    12 
          SX7    B3 
          BX0    X0+X7              LDM REGISTER
          LX0    12 
          SX7    STD+XREG 
          BX0    X0+X7              STD XREG
          RJ     CSTOREB
          SX0    LDD+YREG           LDD YREG
          LX0    12 
          SX7    LMM+XREG 
          BX0    X0+X7
          LX0    12 
          MX7    -12
          BX7    -X7*X2 
          BX0    X0+X7              LMM BUFFER(XREG)
 CXR7     RJ     CSTOREB     STORE CODE 
          JP     B6          EXIT 
          IFEQ   CMSE,0 
          EJECT 
 CXREF    TITLE  CXREF - SAVE CROSS-REFERENCE DATA
**        CXREF - SAVE CROSS-REFERENCE DATA 
* 
*         K.B.SMITH 78/04/27
* 
*         CXREF COMBINES ITEM NAME AND CURRENT LINE NUMBER
*         AND SAVES IT FOR LATER GENERATION OF A CROSS-REFERENCE
*         LISTING.
* 
*         ENTRY 
*                X3 = ITEM NAME LEFT JUSTIFIED WITH ZERO FILL 
* 
*         EXIT
*                XRBUF HAS BEEN UPDATED 
* 
*         ROUTINES CALLED - NONE
* 
*         DATA AREAS USED - XRBUF 
* 
*         USES   A - 5,6. 
*                X - 2,5,6. 
*                B - NONE.
* 
 CXREF    DATA   0                 ENTRY/EXIT 
          BX6    X5 
          SA6    CXREFA 
          SA5    PLINES 
          SX2    LINES
          IX6    X5-X2             CALCULATE LINE NUMBER
          BX6    X6+X3             MERGE WITH NAME
          SA5    PXRBUF 
          SA6    X5                STORE IN XRBUF 
          SX2    XRBUF
          SX2    X2+LXRBUF
          SX6    A6+B1
          IX5    X6-X2
          PL     X5,CXREF1         IF BUFFER IS FULL
          SA6    A5                BUMP BUFFER POINTER
          EQ     CXREF2            RETURN 
 CXREF1   SA5    XRFLAG 
          SX6    X5+B1
          SA6    A5                BUMP LOST REFERENCE COUNT
 CXREF2   SA5    CXREFA 
          EQ     CXREF             RETURN 
 CXREFA   DATA   0                 SAVE X5
          ENDIF 
          EJECT 
 CABSPPU  TITLE  CABSPPU - ABSOLUTIZE PPU DRIVER ADDRESSES
**        CABSPPU - ABSOLUTIZE PPU DRIVER ADDRESSES 
* 
*         K. B. SMITH.  78/03/27. 
* 
*         CABSPPU - THIS ROUTINE CORRECTS ADDRESSES OF ENTRY POINTS 
*         INTO THE PPU DRIVER BASED ON THE CURRENT
*         (OFF-LINE OR ON-LINE) COMPILE MODE. 
* 
*         ENTRY 
* 
*                X0 = RIGHT-MOST 12 BITS ARE TO BE RELOCATED. 
*                     REST OF THE WORD IS NOT CHANGED 
* 
*         EXIT
*                LEAST SIGNIFICANT 12 BITS OF X0 HAVE BEEN
*                RELOCATED
* 
*         ROUTINES CALLED - NONE. 
* 
*         DATA AREAS USED - FCMSE - COMPILE MODE FLAG 
*                           STACKAB - DRIVER RELOCATION TABLE 
* 
*         USES   A - 1
*                X - 0,1,2,5
* 
 CABSPPU  DATA   0                 ENTRY/EXIT 
          SA1    FCMSE             GET MODE FLAG
          SA1    X1+STACKAB        GET RELOCATION 
          MX2    48 
          BX5    -X2*X0            EXTRACT ADDRESS
          BX0    X0*X2
          IX5    X5+X1             ADD RELOCATION 
          BX0    X0+X5             RESTORE ADDRESS
          EQ     CABSPPU           RETURN 
          EJECT 
 FIND     TITLE  FIND - OBTAIN THE NEXT ITEM FROM SOURCE. 
**        FIND - OBTAIN THE NEXT ITEM FROM SOURCE.
* 
*         J. E. SIPPER. 76/12/08. 
* 
*         FIND  -  OBTAIN THE NEXT ITEM FROM CRKBUF AND SCAN THE SEL- 
*         ECTED TABLES FOR THE ITEM.  IFIT IS A BUFFER (IE,OB,IB,SB), 
*         PROCESS  THE  CRKBUF  FARTHER TO DETERMINE IF THE BUFFER IS 
*         SUBSCRIPTED (IE. OB(REGISTER) OR OB(VALUE)).  ALSO  PROVIDE 
*         THE NEXT ITEM  PROCESSED AS A LOOK-AHEAD FEATURE TO THE 
*         CALLING ROUTINE.
* 
*         THIS ROUTINE ASSUMES THAT SCAN DOES NOT CHANGE A3,X1,X3,
*         X4 OR X7. 
* 
*         ENTRY 
* 
*           CRKBUF CONTAINS THE WORD STRING OF THE CRACKED STATEMENT. 
*           X1 = SEARCH CONTROL WORD
* 
*             BITS 00 - 02 = REGISTER TABLE SEARCH. 
*             BITS 03 - 05 = BUFFER   TABLE SEARCH. 
*             BITS 06 - 17 = MAXIMUM OCTAL VALUE TO SEARCH (IF ALLOWED) 
*             BITS 18 - 23 = PRIMARY KEYWORD TABLE TO SEARCH. 
*             BITS 24 - 29 = SECONDARY KEYWORD TABLE TO SEARCH. 
*             BITS 30 - 32 = SEARCH FOR REPLACEMENT STATEMENT 
*             BITS 33 - 38 = MAXIMUM OCTAL UPPER 6BITS. 
*             BITS 39 - 59 = RESERVED.
* 
*           PCRK POINTS TO THE WORD IN THE CRKBUF TO START THE SEARCH.
* 
* 
*         EXIT
* 
*           B2,B3, X2,X4 = DECODE OF CURRENT ITEM FROM CRKBUF.
*               X3       = NEXT RAW ITEM FROM CRKBUF. 
*               X6       = ERROR MESSAGE ADDRESS IF NO FIND IS MADE 
*                          THAT EXPLAINS ERROR. 
*               X5       = OCTAL SUBSCRIPT IF BUFFER(OCTAL) FOUND 
*               B5       = INDEX OF FIND IF BUFFER FOUND
*               X4       = OCTAL SUBSCRIPT IF BUFFER(REGISTER+OCTAL)
* 
*           IF A FIND IS MADE ON A SEARCH FOR A PRIMARY KEYWORD, SEC. 
*           KEYWORD, OR A REPLACEMENT STATEMENT, B2= THE LOWER 18 BITS
*           FROM THE ENTRY FOUND ( NORMALLY THE ENTRY ADDRESS FOR 
*           KEYWORD PROCESSING).
*           FOR OTHER SITUATIONS, THE FOLOWING IS IN REGISTER B2. 
* 
* 
*              B2 = 0  - BUFFER(REGISTER) FOUND 
*                   1  - BUFFER OR BUFFER(VALUE) FOUND
*                   2  - REGISTER FOUND 
*                   3  - VALUE FOUND
*                   4 - 377777 - RESERVED 
*               4XXXXX - ITEM NOT FOUND 
* 
*           B3 = REGISTER VALUE FOUND IN BITS 0 THRU 5.  ZERO IF IT IS
*                NOT A REGISTER OR BUFFER(REGISTER).
* 
*           X2 = FOR PRIMARY AND SECONDARY KEYWORD SEARCHES, X2= INDEX
*                INTO THE STATEMENT TABLE OF THE FIND.  FOR OTHER CASES 
*                X2=  BUFFER ADDRESS OR OCTAL VALUE FOUND IN BITS 0-11. 
*                BITS 12 THRU 17 CONTAIN THE REGISTER VALUE FOUND 
*                (00 IF NOT A REGISTER OR BUFFER(REGISTER)).
* 
*           IF 16 BIT FLAG SET
*           X2 = FOR PRIMARY AND SECONDARY KEYWORD SEARCHES, X2= INDEX
*                INTO THE STATEMENT TABLE OF THE F16D.  FOR OTHER CASES 
*                X2=  BUFFER ADDRESS OR OCTAL VALUE FOUND IN BITS 0-17. 
*                BITS 18 THRU 23 CONTAIN THE REGISTER VALUE FOUND 
*                (00 IF NOT A REGISTER OR BUFFER(REGISTER)).
* 
*           X3 = THE NEXT RAW ITEM FROM THE CRKBUF.  (ZERO IF THE ITEM
*                JUST FOUND IS THE LAST ITEM IN THE WORD STRING.) 
* 
*           IF A FIND IS MADE ON ANY ITEM OTHER THAN A REPLACEMENT
*           STATEMENT, THE  PCRK POINTER IS ADVANCED TO THE NEXT
*           WORD IN THE CRKBUF.  IF NO FIND, IT IS NOT ADVANCED.
* 
* 
*         ROUTINES CALLED -  SCAN - FIND THE INDEX TO A REQUESTED TABLE 
*                                   THAT A REQUESTED ITEM IS LOCATED. 
* 
*         DATA AREAS USED -  CRKBUF- CONTAINS THE WORD STRING.
* 
*         USES   A - 2, 3, 5, 6.
*                X - 1, 2, 3, 4, 5, 6, 7. 
*                B - 2, 3, 4, 5, 6. 
* 
  
**      STEP 01- SET UP INIITAL POINTERS AND VALUES.
* 
 FIND     DATA   0           ENTRY/EXIT 
          SX7    7
          SA2    PCRK 
          SA3    X2          NEXT WORD FROM CRKBUF
          SX4    77B
  
**      STEP 02- SCAN FOR A REGISTER VALUE IF REQUESTED. IF NOT 
*                REQUESTED OR NOT FOUND THEN STEP 03.  EXIT IF FOUND. 
* 
          BX2    X1*X7
          ZR     X2,FIND3    IF NOT A REQISTER REQUEST
          SA2    X2+PREG-1
          RJ     SCAN        SCAN FOR REGISTER
          NG     B4,FIND3    IF NOT FOUND 
          IFEQ   CMSE,0,1 
          RJ     CXREF             SAVE REGISTER REFERENCE
          SB2    B1+B1       REGISTER FOUND CODE
          SB3    X5          REGISTER VALUE FOUND 
          SX2    X5 
          SA1    F16BIT      CHECK 16 BIT FLAG
          ZR     X1,F16D1 
          LX2    18          REGISTER VALUE AND 0000 VALUE
          EQ     FIND1       CONTINUE 
 F16D1    LX2    12          REGISTER VALUE AND 0000 VALUE
 FIND1    SA1    FCMSE                                                   MAL008K
          ZR     X1,FIND2    IF NOT COMPILING OFF-LINE CODE              MAL008K
          SX1    B3-DS
          NG     X1,FIND2    IF NOT PARAMETER REGISTER REFERENCE         MAL008K
          SB3    B3-DS+P0OFF
          MX6    -12                                                     MAL008K
          BX2    -X6*X2      REPLACE REGISTER LOCATION                   MAL008K
          SX6    B3                                                      MAL008K
          LX6    12                                                      MAL008K
          BX2    X2+X6                                                   MAL008K
 FIND2    SX6    A3+B1
          SA6    PCRK        ADVANCE PCRK 
          SA3    X6          NEXT WORD FROM CRKBUF
          EQ     FIND        EXIT 
  
**      STEP 03- SCAN FOR BUFFER IF REQUESTED. IF NOT REQUESTED OR NOT
*                FOUND, GO TO STEP 07. EXIT IF UNSUBSCRIPTED BUFFER IS
*                FOUND. GO TO STEP 04 IF IT IS FOUND AND SUBSCRIPTED. 
* 
 FIND3    AX1    3
          ZR     X1,FIND16   IF NO MORE REQUESTS
          BX2    X1*X7
          ZR     X2,FIND8    IF NOT BUFFER REQUEST
          SA2    X2+PBUF-1
          RJ     SCAN        SCAN FOR BUFFER
          NG     B4,FIND8    IF BUFFER NOT FOUND
          IFEQ   CMSE,0,1 
          RJ     CXREF             SAVE BUFFER REFERENCE
          SB5    B4          INDEX OF FIND TO B5 FOR EXIT CONDITIONS
          SA3    A3+B1       NEXT WORD FROM CRKBUF
          SX2    X3-1R( 
          ZR     X2,FIND4    IF BUFFER IS SUBSCRIPTED 
          SB2    B1          UNSUBSCRIPTED BUFFER FOUND CODE
          SB3    B0 
          SA1    F16BIT      CHECK 16 BIT FLAG
          ZR     X1,FIND3A
          SX2    17777B 
          EQ     FIND3B      CONTINUE 
 FIND3A   SX2    7777B
 FIND3B   BX2    X2*X5       BUFFER PPU ADDRESS 
          SX6    A3 
          SA6    PCRK        ADVANCE PCRK 
          MX5    0           CLEAR SUBSCRIPT FOR EXIT 
          EQ     FIND        EXIT 
  
**      STEP 04- BUFFER VALUE IS SUBSCRIPTED. DETERMINE IF IT IS
*                BUFFER(REGISTER).  IF IT IS, EXIT. IF NOT THEN 
*                STEP 05. 
* 
 FIND4    SA3    A3+B1       NEXT WORD FROM CRKBUF
          SB6    X5          SAVE BUFFER VALUE FOUND IN B6
          SA2    PREG+REG2-1
          RJ     SCAN        SCAN FOR LEGAL REGISTER SUBSCRIPT
          NG     B4,FIND5    IF NOT FOUND 
          IFEQ   CMSE,0,1 
          RJ     CXREF             SAVE REGISTER REFERENCE
          SA3    A3+B1       NEXT WORD FROM CRKBUF
          SX2    X3-1R) 
          SX6    MSG2        ERROR MESSAGE IN CASE OF ERROR 
          MX4    0           CLEAR OCTAL SUBSCRIPT VALUE
          SB3    X5          SAVE REGISTER VALUE
          ZR     X2,FIND4A   IF END OF SUBSCRIPT
          SA2    DPLUS
          BX2    X3-X2
          NZ     X2,FIND17   IF ILLEGAL SUBSCRIPT 
          SA3    A3+B1
          RJ     FINDOCT     CONVERT OCTAL SUBSCRIPT
          SX6    MSG4 
          NG     X5,FIND17   IF ILLEGAL SUBSCRIPT 
          SA3    A3+B1
          SX2    X3-1R) 
          SX6    MSG2 
          NZ     X2,FIND17   IF ILLEGAL SUBSCRIPT 
          SX4    X5          OCTAL PORTION OF SUBSCRIPT TO X4 
 FIND4A   SA1    F16BIT      CHECK 16 BIT FLAG
          NZ     X1,FIND4C
          SB2    B0          BUFFER SUBSCRIPTED FOUND CODE
          SX5    B3          RESTORE BUFFER ADDRESS 
          LX5    12 
          SX2    X4+B6       FORM TOTAL OF BUFFER + OCTAL VALUE 
          AX2    12 
 FIND4B   SX6    MSG4 
          NZ     X2,FIND17   ILLEGAL SUBSCRIPT IF 12 BIT OVERFLOW 
          SX2    X4+B6
          BX2    X2+X5       REGISTER AND VALUE FOUND 
          EQ     FIND1                                                   MAL008K
 FIND4C   SB2    B0          BUFFER SUBSCRIPTED FOUND CODE
          SX5    B3 
          LX5    18 
          SX2    X4+B6       FORM TOTAL OF BUFFER + OCTAL VALUE 
          AX2    16 
          EQ     FIND4B      CONTINUE 
  
**      STEP 05- BUFFER VALUE IS SUBSCRIPTED, BUT NOT WITH A REGISTER.
*                DETERMINE IF IT IS WITH A LEGAL OCTAL VALUE. IF YES, 
*                EXIT. IF NOT THEN STEP 06. 
* 
 FIND5    RJ     FINDOCT     DETERMINE IF X3 IS AN OCTAL VALUE
          NG     X5,FIND7    IF NOT AN OCTAL VALUE
 FIND6    SA2    B5+FINDMAX 
          IX2    X5-X2
          SX6    MSG4        MESSAGE IN CASE OF ERROR 
          PL     X2,FIND17   IF OCTAL VALUE IS TOO LARGE. 
          SA3    A3+B1       NEXT WORD FROM CRKBUF
          SX2    X3-1R) 
          SX6    MSG2        MESSAGE IN CASE OF ERROR 
          NZ     X2,FIND17   IF SUBSCRIPT IS NOT TERMINATED 
          SB2    B1          BUFFER UNSUBCRIPTED FOUND CODE 
          SB3    B0 
          SX2    X5+B6       BUFFER FWA PLUS OCTAL VALUE
          EQ     FIND2       ADVANCE PCRK AND EXIT
  
**      STEP 06- BUFFER VALUE IS SUBSCRIPTED, BUT NOT WITH A REGISTER 
*                OR AN OCTAL VALUE.  DETERMINE IF IT IS WITH A LEGAL
*                EQUATED VALUE FROM THE DATA DIVISION OF THE MODULE.
*                IF YES, EXIT.  IF NOT THEN STEP 12 TO ERROR EXIT.
* 
 FIND7    SA2    PEQUATE
          RJ     SCAN        SCAN EQUATE TABLE
          SX5    X5          VALUE IN LOWER 18 BITS 
          IFEQ   CMSE,0,1 
          RJ     CXREF             SAVE EQUATE SYMBOL REFERENCE 
          PL     B4,FIND6    IF A FIND WAS MADE 
          SX6    MSG4        ERROR MESSAGE
          EQ     FIND17      IF NOT, EXIT WITH NO FIND. 
  
**      STEP 07- SCAN FOR AN OCTAL VALUE IF REQUESTED. IF FOUND, EXIT.
*                IF NOT FOUND THEN STEP 08 TO SEE IF IT IS EQUATED. 
* 
 FIND8    AX1    3
          ZR     X1,FIND16   IF NO MORE REQUESTS
          SX2    7777B
          BX2    X2*X1
          ZR     X2,FIND11   IF OCTAL VALUE NOT REQUESTED.
          BX5    X1          SAVE X1 CONTROL WORD 
          SA1    F16BIT      16-BIT FLAG
          ZR     X1,FIND8A   IF NOT 16-BIT
          BX1    X5          RESTORE X1 CONTROL WORD
          BX4    X1 
          AX4    15          UPPER 6 BITS OF OCTAL VALUE
          BX5    X2          SAVE LOWER 12-BITS OF OCTAL VALUE
          SX2    177777B     16-BIT DIGITS MASK 
          BX2    X2*X4       UPPER 6-BITS OF OCTAL VALUE
          BX2    X2+X5       MERGE UPPER AND LOWER TO FORM 16-BIT VALUE 
          SX4    77B         RESTORE DIGITS MASK
          EQ     FIND8B      DETERMINE THE 16-BIT VALUE 
  
 FIND8A   BX1    X5          RESTORE X1 
 FIND8B   RJ     FINDOCT     DETERMINE IF X3 = OCTAL VALUE
          SX2    X2+B1
          NG     X5,FIND10   IF NOT AN OCTAL VALUE
 FIND9    IX2    X5-X2
          SX6    MSG3        MESSAGE IN CASE OF ERROR 
          PL     X2,FIND17   IF OCTAL VALUE IS TOO LARGE
          SB2    3           OCTAL VALUE FOUND CODE 
          SB3    B0 
          SX2    X5          OCTAL VALUE FOUND
          EQ     FIND2       ADVANCE PCRK AND EXIT
  
**      STEP 08- OCTAL VALUE IS REQUESTED BUT NOT FOUND. DETERMINE IF 
*                IT IS AN EQUATED VALUE. IF SO, EXIT. IF NOT THEN 
*                STEP 09. 
* 
 FIND10   SB6    X2          SAVE MAX OCTAL VALUE ALLOWED 
          SA2    PEQUATE
          RJ     SCAN        SCAN EQUATE TABLE
          SX2    B6          RESTORE MAX OCTAL VALUE ALLOWED
          NG     B4,FIND11   IF NOT FOUND 
          IFEQ   CMSE,0,1 
          RJ     CXREF             SAVE EQUATE SYMBOL REFERENCE 
          SX5    X5          VALUE TO X5
          EQ     FIND9       TEST RANGE OF NUMBER FOUND 
  
**      STEP 09- SCAN FOR PRIMARY KEYWORD IF REQUESTED.  IF NOT 
*                REQUESTED OR NOT FOUND THEN STEP 10.  EXIT IF FOUND. 
* 
 FIND11   AX1    12 
          ZR     X1,FIND16   IF NO MORE REQUESTS
          BX2    X4*X1
          ZR     X2,FIND13   IF PRIMARY KEYWORD SEARCH NOT REQUESTED. 
          SA2    X2+PKEY-1
          RJ     SCAN        SEARCH KEYWORD TABLE 
          NG     B4,FIND13   IF NOT FOUND 
 FIND12   SB2    X5          VALUE FROM KEYWORD FOUND ( ADDRESS ) 
          SB3    B0 
          SX2    B4          INDEX TO KEYWORD FOUND 
          EQ     FIND2       ADVANCE PCRK AND EXIT
  
**      STEP 10- SCAN FOR SECONDARY KEYWORD IF REQUESTED.  IF NOT 
*                REQUESTED OR NOT FOUND THEN STEP 11. EXIT IF FOUND.
* 
 FIND13   AX1    6
          ZR     X1,FIND16   IF NO MORE REQUESTS
          BX2    X4*X1
          ZR     X2,FIND14   IF SECONDARY KEYWORD SEARCH NOT REQUESTED. 
          SA2    X2+PKEY-1
          RJ     SCAN        SCAN KEYWORD TABLE 
          PL     B4,FIND12   IF FOUND 
  
**      STEP 11- SCAN FOR REPLACEMENT STATEMENT IF REQUESTED. IF NOT
*                REQUESTED OR NOT FOUND THEN STEP 12.  EXIT IF FOUND. 
* 
 FIND14   AX1    6
          ZR     X1,FIND16   IF NO MORE REQUESTS
          BX2    X7*X1
          ZR     X2,FIND16   IF NOT REQUESTED 
          SA2    PREG+REG2-1
          RJ     SCAN        SCAN FOR LEGAL REGISTER VALUES FOR W=X.
          PL     B4,FIND15   IF REGISTER VALUE FOUND
          SA2    PBUF+BUF1-1
          RJ     SCAN        SCAN FOR LEGAL BUFFER VALUES FOR W=X.
          NG     B4,FIND16   IF NOT FOUND 
 FIND15   SB2    CWEQX       ENTRY ADDRESS FOR W=X
          SB3    B0 
          MX2    0
          EQ     FIND        EXIT WITHOUT ADVANCING PCRK
  
  
**      STEP 12- FIND HAS BEEN UNABLE TO LOCATE REQUESTED ITEM(S).
*                EXIT WITH ERROR FLAG SET.
* 
 FIND16   SX6    MSG1        SYNTAX ERROR MESSAGE 
 FIND17   SB2    400000B     B2 = ITEM NOT FOUND FLAG 
          SB3    B0 
          MX2    0
          EQ     FIND        EXIT WITHOUT ADVANCING PCRK
  
 PREG     VFD    24/0,18/LREG1,18/TREG1 
 REG1     EQU    *-PREG                   B0-B7, WC, BA 
          VFD    24/0,18/LREG2,18/TREG2 
 REG2     EQU    *-PREG                   B0-B7,P0-P9,WT,LF,P,EC,EA,DC
          VFD    24/0,18/LREG3,18/TREG3               AL, EM
 REG3     EQU    *-PREG                   REG2 + RT 
          VFD    24/0,18/LREG4,18/TREG4 
 REG4     EQU    *-PREG                   P0,P1 
  
  
 PBUF     VFD    24/0,18/LBUF1,18/TBUF1 
 BUF1     EQU    *-PBUF                   OB,IB 
          VFD    24/0,18/LBUF2,18/TBUF2 
 BUF2     EQU    *-PBUF                   OB,IB,SB
          VFD    24/0,18/LBUF3,18/TBUF3 
 BUF3     EQU    *-PBUF                   SB
          VFD    24/0,18/LBUF4,18/TBUF4 
 BUF4     EQU    *-PBUF                   IB
          VFD    24/0,18/LBUF5,18/TBUF5 
 BUF5     EQU    *-PBUF                   IB,SB 
          VFD    24/0,18/LBUF6,18/TBUF6 
 BUF6     EQU    *-PBUF                   OB
  
  
*         LEGAL REGISTER TABLES.
*         THE ORDER OF THESE TABLES MUST NOT BE CHANGED.
  
 TREG1    BSS    0
 TREG2    BSS    0
 TREG3    VFD    42/2LB0,18/20B 
          VFD    42/2LB1,18/21B 
          VFD    42/2LB2,18/22B 
          VFD    42/2LB3,18/23B 
          VFD    42/2LB4,18/24B 
          VFD    42/2LB5,18/25B 
          VFD    42/2LB6,18/26B 
          VFD    42/2LB7,18/27B 
          VFD    42/2LWC,18/30B 
          VFD    42/2LBA,18/31B 
         VFD    42/2LB8,18/32B
         VFD    42/2LB9,18/33B
         VFD    42/3LB10,18/34B 
         VFD    42/3LB11,18/35B 
         VFD    42/3LB12,18/36B 
         VFD    42/3LB13,18/37B 
         VFD    42/3LB14,18/40B 
         VFD    42/3LB15,18/41B 
 XREG     EQU    42B         SCRATCH DIRECT CELL FOR COMPILE USE
 YREG     EQU    43B         SCRATCH DIRECT CELL FOR COMPILE USE
 LREG1    EQU    *-TREG1               END OF TREG1 
 DS       EQU    4460B       ADDRESS OF DS REGISTER 
 P0OFF    EQU    4265B       CMSE ADDRESS OF DS+P0-P9 REGISTERS 
 P0       EQU    4461B       DEFINES LOCATION OF P0 IN PPU
 P1       EQU    P0+1 
 TREG4    VFD    42/2LP0,18/P0
          VFD    42/2LP1,18/P1
 LREG4    EQU    *-TREG4               END OF TREG4 
          VFD    42/2LP2,18/P0+2
          VFD    42/2LP3,18/P0+3
          VFD    42/2LP4,18/P0+4
          VFD    42/2LP5,18/P0+5
          VFD    42/2LP6,18/P0+6
          VFD    42/2LP7,18/P0+7
          VFD    42/2LP8,18/P0+8
          VFD    42/2LP9,18/P0+9
          VFD    42/2LDS,18/DS        ADDRESS OF DS REGISTER
          VFD    42/2LWT,18/44B 
          VFD    42/2LLF,18/45B 
          VFD    42/2LEC,18/47B        ERROR CODE 
          VFD    42/2LEA,18/50B        ERROR ADDRESS
          VFD    42/2LEM,18/51B        ERROR MESSAGE INDEX
          VFD    42/2LDC,18/52B        DEVICE CODE
          VFD    42/2LAL,18/53B        ACCESS LEVEL 
          VFD    42/2LES,18/57B        EXECUTIVE SWITCHES 
 P        EQU    46B         DEFINES DIRECT CELL FOR P
          VFD    42/1LP,18/P
 LREG2    EQU    *-TREG2                                                 MAL051G
 RT       EQU    *-TREG3+20B           UNIQUE IDENTIFIER FOR RT CLOCK 
          VFD    42/2LRT,18/RT
 LREG3    EQU    *-TREG3               END OF TREG3 
  
*         LEGAL BUFFER TABLES.
*         THE ORDER OF THESE TABLES MUST NOT BE CHANGED.
  
 TBUF6    BSS    0
 TBUF1    BSS    0
 TBUF2    VFD    42/2LOB,18/7200B 
 LBUF6    EQU    *-TBUF6               END OF TBUF6 (OB)
 TBUF4    BSS    0
 TBUF5    VFD    42/2LIB,18/6500B 
 LBUF1    EQU    *-TBUF1               END OF TBUF1 (OB,IB) 
 LBUF4    EQU    *-TBUF4               END OF TBUF4 (IB)
 TBUF3    VFD    42/2LSB,18/7700B 
 LBUF2    EQU    *-TBUF2               END OF TBUF2 (OB,IB,SB)
 LBUF3    EQU    *-TBUF3               END OF TBUF3 (SB)
 LBUF5    EQU    *-TBUF5               END OF TBUF5 (IB,SB) 
  
  
*         LEGAL STATEMENT KEYWORDS TABLE. 
  
 TKEY1    VFD    42/4LBASE,18/CBASE    DATA DIVISION KEYWORDS 
          VFD    42/4LDATA,18/CDATA 
          VFD    42/6LEQUATE,18/CEQUATE 
          VFD    42/6LFORMAT,18/CFORMAT 
 LKEY1    EQU    *-TKEY1
  
 TKEY2    VFD    42/5LBLANK,18/CBLANK    CODE DIVISION KEYWORDS 
          VFD    42/4LCALL,18/CCALL      FOR NON I/0 STATEMENTS 
          VFD    42/7LCHANNEL,18/CCHANNL                                 MAL011K
          VFD    42/7LCOMPARE,18/CCBF 
          VFD    42/4LCOPY,18/CCOPY 
          VFD    42/5LDELAY,18/CDELAY 
          VFD    42/3LDUP,18/CDUP 
          VFD    42/3LEND,18/CEND 
          VFD    42/6LENDSUB,18/CENDSUB 
          VFD    42/5LERROR,18/CERROR 
          VFD    42/4LEXIT,18/CEXIT 
          VFD    42/4LFZCP,18/CFZCP                                      MAL011K
          VFD    42/5LGOSUB,18/CGOSUB 
          VFD    42/4LGOTO,18/CGOTO 
          VFD    42/4LHALT,18/CHALT 
          VFD    42/2LIF,18/CIF 
          VFD    42/3LLOG,18/CLOG 
          VFD    42/3LMSG,18/CMSG 
          VFD    42/4LPASS,18/CPASS 
          VFD    42/5LPAUSE,18/CPAUSE 
          VFD    42/7LPICTURE,18/CPICTUR
          VFD    42/4LPLOT,18/CPLOT 
          VFD    42/6LRANDOM,18/CRANDOM 
          VFD    42/6LRETURN,18/CRETURN 
          VFD    42/5LSYSRD,18/CYSRD
          VFD    42/6LSYSREW,18/CYSREW
          VFD    42/5LSYSWR,18/CYSWR
 LKEY2    EQU    *-TKEY2
  
*         LEGAL OP TABLES.
*         THE ORDER OF THESE TABLES MUST NOT BE CHANGED.
  
 TKEY3    BSS    0
 TKEY4    VFD    42/1L+,18/CADD 
          VFD    42/1L-,18/CMINUS 
 LKEY3    EQU    *-TKEY3                  END OF TKEY3
          VFD    42/3LAND,18/CAND 
          VFD    42/2LOR,18/COR 
          VFD    42/3LXOR,18/CXOR 
          VFD    42/2LRS,18/CRS 
          VFD    42/2LLS,18/CLS 
 LKEY4    EQU    *-TKEY4                  END OF TKEY4
  
*         LEGAL COND TABLE
*         THE ORDER OF THIS TABLE MUST NOT BE CHANGED.
  
 TKEY5    VFD    42/2LEQ,18/CEQ 
          VFD    42/2LNE,18/CNE 
          VFD    42/2LLT,18/CLT 
          VFD    42/2LGT,18/CGT 
          VFD    42/2LLE,18/CLE 
          VFD    42/2LGE,18/CGE 
 LKEY5    EQU    *-TKEY5                 END OF TKEY5 
  
  
  
 TKEY6    VFD    42/6LSOURCE,18/FSOURCE   COMPILE CARD OPTIONS
          VFD    42/1LS,18/FSOURCE                                       MAL036G
          VFD    42/4LLIST,18/FLIST 
          VFD    42/1LL,18/FLIST                                         MAL036G
 LKEY6    EQU    *-TKEY6
  
*         LEGAL 12/16-BIT LANGUAGE TYPES SUPPORTED AND THEIR OCTAL
*         VALUES. ALL ADDITIONAL LANGUAGE TYPES MUST BE ADDED TO THIS 
*         TABLE.
  
 TKEY7    VFD    42/4L3000,18/0 
          VFD    42/4L6000,18/1 
          VFD    42/2LBC,18/2 
          VFD    42/3L66X,18/3         DEVICE TYPES SUPPORTED 
          VFD    42/3L580,18/4         AND THEIR OCTAL VALUES 
          VFD    42/4L667X,18/5 
          VFD    42/5L844HT,18/6
          VFD    42/5L844FT,18/7
          VFD    42/3L841,18/8
          VFD    42/3L65X,18/9
          VFD    42/3L67X,18/10 
          VFD    42/5LFMDHT,18/11 
          VFD    42/5LFMDFT,18/12 
          VFD    42/3LCSU,18/13 
          VFD    42/3LMST,18/14 
          VFD    42/3LMSC,18/15                                          MAL013G
          VFD    42/3LLCN,18/16 
          VFD    42/5LDEMA1,18/17 
          VFD    42/5LDEMA2,18/18 
          VFD    42/5LDEMA3,18/19 
          VFD    42/4LFSD1,18/20
          VFD    42/6LLSFMD1,18/21
          VFD    42/6LLSFMD2,18/22
          VFD    42/4LLCN2,18/23
          VFD    42/5LDCART,18/24 
          VFD    42/6LPFMDW3,18/25
          VFD    42/5LFMDSS,18/26 
          VFD    42/4LFSD2,18/27
          VFD    42/4LD895,18/28
          VFD    42/5LP895D,18/29 
          VFD    42/4LDESM,18/30
          VFD    42/4LIFSD,18/31
          VFD    42/4LDDAS,18/32
 LKEY7    EQU    *-TKEY7
  
*         LEGAL 16-BIT LANGUAGE TYPES SUPPORTED AND THEIR OCTAL VALUES. 
*         ALL ADDITIONAL 16-BIT LANGUAGE TYPES MUST BE ADDED TO THIS
*         TABLE.
  
 TKEY8    VFD    42/6LPFMDW3,18/25
          VFD    42/4LIFSD,18/31
          VFD    42/4LDDAS,18/32
 LKEY8    EQU    *-TKEY8
  
          IFEQ   CMSE,0 
*         THIS TABLE MUST BE IN THE SAME ORDER AS TKEY7 
* 
 OVLPT    VFD    42/0,18/OVLP0
          VFD    42/0,18/OVLP1
          VFD    42/0,18/OVLP2
          VFD    42/0,18/OVLP3
          VFD    42/0,18/OVLP4
          VFD    42/7,18/OVLP4
          VFD    42/0,18/OVLP6
          VFD    42/0,18/OVLP7
          VFD    42/0,18/OVLP8
          VFD    42/0,18/OVLP9
          VFD    42/0,18/OVLPA
          VFD    42/0,18/OVLPB
          VFD    42/0,18/OVLPC
          VFD    42/0,18/OVLPD                                           MAL013G
          VFD    42/0,18/OVLPE
          VFD    42/0,18/OVLPF
          VFD    42/0,18/OVLPG
          VFD    42/0,18/OVLPH
          VFD    42/0,18/OVLPI
          VFD    42/0,18/OVLPJ
          VFD    42/0,18/OVLPK
          VFD    42/0,18/OVLPL
          VFD    42/0,18/OVLPM
          VFD    42/0,18/OVLPN
          VFD    42/0,18/OVLPO
          VFD    42/0,18/OVLPP
          VFD    42/0,18/OVLPQ
          VFD    42/0,18/OVLPR
          VFD    42/0,18/OVLPS
          VFD    42/0,18/OVYPT
          VFD    42/0,18/OVYPU
 OVLP0    OVLTAB 7LMALET21,2,1
 OVLP1    OVLTAB 7LMALET22,2,2
 OVLP2    OVLTAB 7LMALET23,2,3
 OVLP3    OVLTAB 7LMALET24,2,4
 OVLP4    OVLTAB 7LMALET25,2,5
 OVLP6    OVLTAB 7LMALET26,2,6
 OVLP7    OVLTAB 7LMALET27,2,7
 OVLP8    OVLTAB 7LMALET28,2,8
 OVLP9    OVLTAB 7LMALET29,2,9
 OVLPA    OVLTAB 7LMALET2A,2,10 
 OVLPB    OVLTAB 7LMALET2B,2,11 
 OVLPC    OVLTAB 7LMALET2C,2,12 
 OVLPD    OVLTAB 7LMALET2D,2,13                                          MAL013G
 OVLPE    OVLTAB 7LMALET2E,2,14 
 OVLPF    OVLTAB 7LMALET2F,2,15 
 OVLPG    OVLTAB 7LMALET2G,2,16 
 OVLPH    OVLTAB 7LMALET2H,2,17 
 OVLPI    OVLTAB 7LMALET2I,2,18 
 OVLPJ    OVLTAB 7LMALET2J,2,19 
 OVLPK    OVLTAB 7LMALET2K,2,20 
 OVLPL    OVLTAB 7LMALET2L,2,21 
 OVLPM    OVLTAB 7LMALET2M,2,22 
 OVLPN    OVLTAB 7LMALET2N,2,23 
 OVLPO    OVLTAB 7LMALET2O,2,24 
 OVLPP    OVLTAB 7LMALET2P,2,25 
 OVLPQ    OVLTAB 7LMALET2Q,2,26 
 OVLPR    OVLTAB 7LMALET2R,2,27 
 OVLPS    OVLTAB 7LMALET2S,2,28 
 OVYPT    OVLTAB 7LMALET2T,2,29 
 OVYPU    OVLTAB 7LMALET2U,2,30 
          ENDIF 
 FINDMAX  DATA   0           *** MAX VALUE FOR OB STORED HERE 
          DATA   0           *** MAX VALUE FOR IB STORED HERE 
          DATA   0           *** MAX VALUE FOR SB STORED HERE 
  
*         TO ADD ADDITIONAL PRODUCT OVERLAY SUPPORT, ADDITIONS  MUST
*         BE MADE TO THIS KEYWORD CONTROL WORDS TABLE.
  
          IFNE   CMSE,0,1 
          USE    PKEY 
 PKEY     VFD    24/0,18/LKEY1,18/TKEY1 
 KEY1     EQU    *-PKEY                DATA DIVISION LEGAL STATEMENTS 
          VFD    24/0,18/LKEY2,18/TKEY2 
 KEY2     EQU    *-PKEY                NON-I/O CODE DIVISION STATEMENTS 
          VFD    24/0,18/LKEY3,18/TKEY3 
 KEY3     EQU    *-PKEY                OP KEYWORDS +  - 
          VFD    24/0,18/LKEY4,18/TKEY4 
 KEY4     EQU    *-PKEY                OP KEYWORDS + - AND OR XOR RS LS 
          VFD    24/0,18/LKEY5,18/TKEY5 
 KEY5     EQU    *-PKEY                LEGAL COND KEYWORDS
          VFD    24/0,18/LKEY6,18/TKEY6 
 KEY6     EQU    *-PKEY                LEGAL COMPILE CARD OPTIONS 
          VFD    24/0,18/LKEY7,18/TKEY7 
 KEY7     EQU    *-PKEY                LEGAL 12/16-BIT LANGUAGE TYPES 
          VFD    24/0,18/LKEY8,18/TKEY8 
 KEY8     EQU    *-PKEY                LEGAL 16-BIT LANGUAGE TYPES
          USE    *
          IFEQ   CMSE,0 
          EJECT 
* 
*         DEFINE OVERLAY AREA 
* 
 AREA3    BSS    5                 SPACE FOR OVERLAY TABLE
 OVAREA   EQU    AREA3
          ENTRY  AREA3
          ENTRY  PKEYOFF
 PKEYOFF  EQU    *-PKEY 
 MODD     BSS    1                 STATEMENT CONTROL WORD 
 P0OB     BSS    1                 LENGTH OF OB 
 P0OBFWA  BSS    1                 FWA OF OB
 P0IB     BSS    1                 LENGTH OF IB 
 P0IBFWA  BSS    1                 FWA OF IB
 P0SB     BSS    1                 LENGTH OF SB 
 P0SBFWA  BSS    1                 FWA OF SB
          ORG    MODD 
 ENTRIES  SET    0
 XREFM    LINK
          ORG    *
          ENDIF 
          IFNE   CMSE,0 
          EJECT 
* 
*         DEFINE PRODUCT OVERLAY TABLE AREAS
* 
          USE    MODD 
 MODD     BSS    0                 STATEMENT CONTROL WORD TABLE 
          USE    *
          USE    P0OB 
 P0OB     BSS    0                 LENGTH OF OB TABLE 
          USE    *
          USE    P0OBFWA
 P0OBFWA  BSS    0                 FWA OF OB TABLE
          USE    *
          USE    P0IB 
 P0IB     BSS    0                 LENGTH OF IB TABLE 
          USE    *
          USE    P0IBFWA
 P0IBFWA  BSS    0                 FWA OF IB TABLE
          USE    *
          USE    P0SB 
 P0SB     BSS    0                 LENGTH OF SB TABLE 
          USE    *
          USE    P0SBFWA
 P0SBFWA  BSS    0                 FWA OF SB TABLE
          USE    *
 PKEYOFF  EQU    0
          ENDIF 
