*DECK CGENINT 
          IDENT  CGENINT
          TITLE  CGENINT -  INTERPRET CGEN COMMAND(S) 
          COMMENT  INTERPRET CGEN COMMAND(S)
          SST                      ACCESS *DEBUGA*, *DEBUGC* OPTIONS
          LIST   F
  
          QUAL   COMPRESS 
 EVALADDR EQU    0           COMPRESS *EVALADDR* MACRO
 RESTORE  EQU    0           COMPRESS *RESTORE* MACRO 
 SAVE     EQU    0           COMPRESS *SAVE* MACRO
 SKIPADDR EQU    0           COMPRESS *SKIPADDR* MACRO
 STORFUNC EQU    0           COMPRESS *STORFUNC* MACRO
          QUAL   *
          SPACE  4
**        CGENINT -  INTERPRET CGEN COMMAND(S)
* 
*      FOR THE NON-DEBUG VERSION, 
*         CGENINT INTERPRETS ALL COMMANDS STARTING AT 
*         WORD  INT$ADDR  AND BIT POSITION  INT$POS  (SIGN BIT = 0) 
*         (IN COMDECK INT$).  INTERPRETATION STOPS WHEN A *STOPZ* 
*         COMMAND IS ENCOUNTERED. 
* 
*      FOR THE DEBUG VERSION, 
*         CGENINT RETURNS AFTER EXECUTING EACH COMMAND. 
          TITLE  REGISTER DECLARATIONS
*CALL CGENREGS
          SPACE     4 
          NOREF  FIX,LOD,GET,TMP,CMD,STO,SAV
          NOREF  .0,.1,SCR,CNT,LFT,LIM
          TITLE  MACRO DEFINITIONS
ALIGN     SPACE  4
**        ALIGN -  ALIGN COMMAND BITS INTO X.CMD
* 
*      CALLING FORM:  
*         ALIGN  NBITS
* 
*      DOES:  
*         ENSURES THAT *NBITS* UNUSED COMMAND BITS ARE LEFT-JUSTIFIED 
*         IN X.CMD
  
  
 ALIGN    MACRO  NBITS
          LOCAL  NEXT 
          ERRPL  NBITS-61    ILLEGAL N_BITS   "SEQUENCE"
          SB.TMP NBITS
          GE     B.LFT,B.TMP,NEXT 
          RJ     ALIGN
 NEXT     BSS    0
 ALIGN    ENDM
$BEGIN    SPACE  4,7
**        $BEGIN -  DECLARE DEBUG-ONLY CODE 
* 
*      CALLING FORM:  
*         $BEGIN
* 
*      DOES:  
*         SKIPS LINES UNTIL A $END OR UNLABELED ENDIF IS ENCOUNTERED. 
  
  
          MACRO  $BEGIN,BRACK 
BRACK     IFEQ   DEBUGC,1          IF DEBUG VERSION OF COMPILER 
 $BEGIN   ENDM
CMD@60    SPACE  4,16 
**        CMD@60 -  ENSURE BITS USED FOR THIS COMMAND @ 60
* 
*      CALLING FORM:  
*         CMD@60 A+B+...+Z
*      OR 
*         CMD@60 A+B+...+Z,(NEXT) 
* 
*      DOES:  
*         IF A+B+...+Z > 60,
*             GENERATES A FATAL ASSEMBLY ERROR. 
*         IF (NEXT) IS SPECIFIED AND A+B+...+Z+NEXT @ 60, 
*             GENERATES A NON-FATAL ASSEMBLY ERROR. 
* 
*      NOTE-
*         *FUNC* AND *ADDR* MAY BE USED IN THE EXPRESSION(S)
*         FOR FUNCTION AND ADDRESS, RESPECTIVELY. 
*         THESE SYMBOLS ARE DEFINED JUST AFTER THE  W$  DATA DECLARATION
  
  
 CMD@60   MACRO  EXPR,NXT 
          IFGT   EXPR,60,1
          ERR    NEED TO *ALIGN* COMMAND                   "SEQUENCE" 
          IFC    NE,#_NXT_##,2
          IFLE   EXPR+NXT,60,1
 2        ERR    MAY *ALIGN* AFTER NEXT *NXT*              "SEQUENCE" 
 CMD@60   ENDM
CHECKOT   SPACE  4,11 
**        CHECKOT -  CHECK OTEXT BUFFER FOR X.TMP CONTIGUOUS WORDS
* 
*      CALLING FORM:  
*         X.TMP = NUMBER OF CONTIGUOUS WORDS DESIRED. 
*         CHECKOT                  ENSURE ROOM FOR ... WORDS
* 
*      DOES:  
*         ENSURES THAT /OTXT/PTR INDEXES THE OTEXT BUFFER 
*         SO THAT THE BUFFER HAS X.TMP CONTIGUOUS WORDS STARTING AT 
*         /OTXT/WORD+(/OTXT/PTR). 
*         IF NECESSARY,  *FLUSHOT* IS CALLED TO CLEAR THE BUFFER. 
  
  
 CHECKOT  MACRO 
          LOCAL  NEXT 
          SA.LOD /OTXT/PTR
          SA.GET /OTXT/LIM
          IX.LOD X.LOD+X.TMP       PTR + NUMBER OF WORDS
          IX.LOD X.LOD-X.GET
          NG     X.LOD,NEXT        IF ENOUGH ROOM 
          SAVE                     SAVE RELEVANT REGISTERS
          RJ     =X_FLUSHOT        FLUSH OTEXT BUFFER 
          RESTORE                  RESTORE RELEVANT REGISTERS 
          MX.STO 0
          SA.STO /OTXT/PTR
          $BEGIN
          SA.STO /BUG202C/OTXT
          $END
 NEXT     BSS    0
 CHECKOT  ENDM
$END      SPACE  4,13 
**        $END -  TERMINATE A BLOCK OF DEBUG-ONLY CODE
* 
*      CALLING FORM:  
*         $BEGIN
*         ... 
*         $END
* 
*      DOES NOT:  
*         ASSEMBLE THE LINES BETWEEN THE $BEGIN AND $END. 
* 
*      NOTE-
*         THE $END CANNOT BE DECLARED AS A MACRO BECAUSE
*         MACROS ARE NOT EXPANDED WHEN LINES ARE SKIPPED. 
  
  
 $END     OPSYN  ENDIF
EVALADDR  SPACE  4,9
**        EVALADDR -  EVALUATE ADDRESS
* 
*      COMMAND: 
*         1/0, W$JUMP/<MODULE OFFSET> 
*      OR 
*         1/1,N/-0,1/0,17/ABSOLUTE ADDRESS
* 
*      DOES:  
*         SETS X.TMP = ABSOLUTE ADDRESS OF THE ADDRESS. 
  
  
COMPRESS  IF     -DEF,/COMPRESS/EVALADDR
  
 EVALADDR MACRO 
          LOCAL  NEXT,LONG,LONG1,LONG2
          NG     X.CMD,LONG        IF LONG ADDRESS
          LX.CMD 1+W$JUMP          RIGHT-JUSTIFY OFFSET FROM MODULE 
          MX.TMP -W$JUMP
          SB.LFT B.LFT-1-W$JUMP    DECREMENT NO. BITS LEFT IN X.CMD 
          BX.TMP -X.TMP*X.CMD      EXTRACT OFFSET 
          ZR     X.TMP,NEXT        IF *RETURN*, LEAVE ADDRESS = 0 
          SA.LOD /INT/MODADR
          IX.TMP X.LOD+X.TMP       COMPUTE ABSOLUTE ADDRESS 
 NEXT     BSS    0
1         $BEGIN
          BX.STO X.TMP             SAVE ADDRESS FOR DEBUG TRACE 
          SA.STO /BUG202C/JUMP
1         $END
          USE    LONGADR
 LONG     LX.CMD 1                 SKIP THE *1* BIT 
          PL     X.CMD,LONG2       IF ADDRESS IS IN SAME WORD 
          SA.WRD A.WRD             UNSHIFT NEXT WORD
          NZ     B.CNT,LONG1       IF A.WRD WAS REALLY NEXT WORD
          SA.WRD A.WRD+1           (BLUSH),  UNSHIFT NEXT WORD
 LONG1    SB.CNT B..0              NOTE THAT NO BITS WILL BE IN X.WRD 
          BX.CMD X.WRD
          SB.LFT 61                (WILL HAVE 42 BITS)
 LONG2    LX.CMD 18                RIGHT-JUSTIFY ADDRESS
          SX.TMP X.CMD             EXTRACT ADDRESS
          SB.LFT B.LFT-1-18        DECREMENT NO. BITS LEFT IN X.CMD 
          EQ     NEXT              DONE 
          USE    *
 EVALADDR ENDM
  
COMPRESS  ELSE
  
 EVALADDR MACRO 
          RJ     EVALADDR 
1         $BEGIN
          BX.STO X.TMP
          SA.STO /BUG202C/JUMP
1         $END
 EVALADDR ENDM
  
 EVALADDR BSS    1           ENTRY/EXIT WORD
          NG     X.CMD,EVALADD1    IF LONG ADDRESS
          LX.CMD 1+W$JUMP          RIGHT-JUSTIFY OFFSET FROM MODULE 
          MX.TMP -W$JUMP
          SB.LFT B.LFT-1-W$JUMP    DECREMENT NO. BITS LEFT IN X.CMD 
          BX.TMP -X.TMP*X.CMD      EXTRACT OFFSET 
          ZR     X.TMP,EVALADDR    IF *RETURN*, LEAVE ADDRESS = 0 
          SA.LOD /INT/MODADR
          IX.TMP X.LOD+X.TMP       COMPUTE ABSOLUTE ADDRESS 
          EQ     EVALADDR          EXIT 
  
 EVALADD1 LX.CMD 1                 SKIP THE *1* BIT 
          PL     X.CMD,EVALADD3    IF ADDRESS IS IN SAME WORD 
          SA.WRD A.WRD             UNSHIFT NEXT WORD
          NZ     B.CNT,EVALADD2    IF A.WRD WAS REALLY NEXT WORD
          SA.WRD A.WRD+1           (BLUSH),  UNSHIFT NEXT WORD
 EVALADD2 SB.CNT B..0              NOTE THAT NO BITS WILL BE IN X.WRD 
          BX.CMD X.WRD
          SB.LFT 61                (WILL HAVE 42 BITS)
 EVALADD3 LX.CMD 18                RIGHT-JUSTIFY ADDRESS
          SX.TMP X.CMD             EXTRACT ADDRESS
          SB.LFT B.LFT-1-18        DECREMENT NO. BITS LEFT IN X.CMD 
          EQ     EVALADDR          DONE 
  
COMPRESS  ENDIF 
EVALFUNC  SPACE  4,6
**        EVALFUNC -  EVALUATE A FUNCTION/FIXED CELL
* 
*         EVALFUNC
* 
*         SETS X.TMP = VALUE OF FUNCTION/FIXED CELL.
*         PRESERVES X.SAV AND BACKGROUND REGISTERS/CONSTANTS
  
  
  
 EVALFUNC MACRO 
          RJ     EVALFUNC 
 EVALFUNC ENDM
  
 EVALFUNC BSS    1
          NG     X.CMD,EVALFUN1    IF FUNCTION
          LX.CMD 1+W$FIXED         RIGHT-JUSTIFY INDEX TO FIXED CELL
          BX.TMP -X.FIX*X.CMD      EXTRACT INDEX
          SB.LFT B.LFT-1-W$FIXED   ADJUST NO. BITS LEFT IN X.CMD
1         IFEQ   DEBUGC,1          IF DEBUG VERSION OF COMPILER 
          BX.STO X.TMP             SAVE ARGUMENT FOR TRACE
          SA.LOD /BUG202C/PTR 
          SA.STO /BUG202C/ARG+X.LOD+1 
1         ENDIF 
          SA.TMP FIXCELLS+X.TMP    PICK UP VALUE OF FIXED CELL
1         $BEGIN
          BX.STO X.TMP
          SA.STO /BUG202C/VFUN+X.LOD+1
          SX.STO X.LOD+B..1 
          SA.STO A.LOD
1         $END
          EQ     EVALFUNC    DONE 
  
 EVALFUN1 BSS    0
          LX.CMD 1+W$FUNC          RIGHT-JUSTIFY FUNCTION NUMBER
  
          ERRNZ  W$FUNC-W$FIXED   CHANGE BELOW INSTRS.  "SEQUENCE"
          BX.STO -X.FIX*X.CMD 
  
          SA.STO /INT/FUN          STORE FOR *VALFUNC*
          LX.CMD W$FIXED           RIGHT-JUSTIFY INDEX TO PARAMETER 
          BX.STO -X.FIX*X.CMD      EXTRACT ACTUAL PARAMETER 
          SA.STO /INT/ARG          STORE FOR *VALFUNC*
          SB.LFT B.LFT-1-W$FUNC-W$FIXED  DECREMENT BITS LEFT IN X.CMD 
          SA.LOD FIXCELLS+X.STO    LOAD POSSIBLE FIXED CELL PARAMETER 
          BX.STO X.LOD
          SA.STO /INT/VARG         STORE FOR *VALFUNC*  (MAYBE) 
          SA.LOD /INT/FUN 
          SA.GET X.LOD+=XCFUNCS 
          ZR     X.GET,EVALFUN2 
          $BEGIN
          MX.STO 60 
          SA.STO /INT/VFIX
          $END
          RJ     =XEVALCFN   COMPASS FUNCTION 
          $BEGIN
          SA.SAV X=SAV
          BX.STO X.TMP
          SA.STO /INT/VFUN
          SA.TMP /BUG202C/PTR      INDEX TO SAVED FUNCTIONS 
          SX.STO X.TMP+1           INCREMENT INDEX
          SA.STO A.TMP
          SA.LOD /INT/ARG          STACK INT$ARG
          SA.GET /INT/FUN          STACK INT$FUN
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/ARG+X.TMP+1 
          SA.SAV /BUG202C/FUN+X.TMP+1 
          SA.LOD /INT/VARG         STACK INT$VARG 
          SA.GET /INT/VFUN         STACK INT$VFUN 
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/VARG+X.TMP+1
          SA.SAV /BUG202C/VFUN+X.TMP+1
          SA.LOD /INT/VFIX         STACK INT$VFIX 
          SA.GET /INT/TABL         STACK INT$TABL 
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/VFIX+X.TMP+1
          SA.SAV /BUG202C/TABL+X.TMP+1
          SA.GET X=SAV
          BX.SAV X.GET
          SA.TMP /INT/VFUN
          $END
          EQ     EVALFUNC 
          SPACE  3
 EVALFUN2 BSS    0                 SYMPL FUNCTION 
  
          SA.SAV X=SAV             X.SAV
          BX.STO X.WRD
          LX.SAV X.CMD
          SA.STO A.SAV+B..1        X.WRD
          SA.SAV A.STO+B..1        X.CMD
          SX.STO B.CNT
          SX.SAV A.WRD
          PX.STO B.LFT,X.STO
          SA.SAV A.SAV+B..1        A.WRD
          SA.STO A.SAV+B..1        12/2000B+B.LFT,48/B.CNT
          RJ     =X_VALFUNC        EVALUATE THE FUNCTION
  
1         $BEGIN
          SA.TMP /BUG202C/PTR      INDEX TO SAVED FUNCTIONS 
          SX.STO X.TMP+1           INCREMENT INDEX
          SA.STO A.TMP
          SA.LOD /INT/ARG          STACK INT$ARG
          SA.GET /INT/FUN          STACK INT$FUN
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/ARG+X.TMP+1 
          SA.SAV /BUG202C/FUN+X.TMP+1 
          SA.LOD /INT/VARG         STACK INT$VARG 
          SA.GET /INT/VFUN         STACK INT$VFUN 
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/VARG+X.TMP+1
          SA.SAV /BUG202C/VFUN+X.TMP+1
          SA.LOD /INT/VFIX         STACK INT$VFIX 
          SA.GET /INT/TABL         STACK INT$TABL 
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/VFIX+X.TMP+1
          SA.SAV /BUG202C/TABL+X.TMP+1
1         $END
  
          SA.LOD B=LFTCNT          12/2000B+B.LFT, 48/B.CNT 
          SB..1  1               * CONSTANT 1 
          UX.TMP B.LFT,X.LOD     * B.LFT
          SA.GET A.LOD-B..1        GET A.WRD
          SB.CNT X.TMP           * B.CNT
          SA.WRD X.GET           * A.WRD
          SA.CMD A.GET-B..1      * CORRECTLY SHIFTED X.CMD
          SB..60 60              * CONSTANT 60
          SA.LOD A.CMD-B..1        GET CORRECTLY SHIFTED X.WRD
          MX.FIX -W$FIXED        * MASK OF -W$FIXED 
          SA.GET A.LOD-B..1        X.SAV
          BX.WRD X.LOD           * CORRECTLY SHIFTED X.WRD
          BX.SAV X.GET           * X.SAV
          SA.TMP /INT/VFUN
          EQ     EVALFUNC    DONE 
  
RESTORE   SPACE  4,9
**        RESTORE -  RESTORE RELEVANT REGISTERS SAVED BY *SAVE* 
* 
*      CALLING FORM:  
*         RESTORE 
* 
*      DOES:  
*         RESETS CONSTANTS B..1, B..60 AND X.FIX. 
*         RESTORES COMMAND REGISTERS X.CMD, X.WRD, A.WRD, B.LFT, B.CNT. 
*         RESTORES SAVE REGISTER X.SAV. 
  
  
COMPRESS  IF     -DEF,/COMPRESS/RESTORE 
  
 RESTORE  MACRO 
          SA.LOD B=LFTCNT          12/2000B+B.LFT, 48/B.CNT 
          SB..1  1               * CONSTANT 1 
          UX.TMP B.LFT,X.LOD     * B.LFT
          SA.GET A.LOD-B..1        GET A.WRD
          SB.CNT X.TMP           * B.CNT
          SA.WRD X.GET           * A.WRD
          SA.CMD A.GET-B..1      * CORRECTLY SHIFTED X.CMD
          SB..60 60              * CONSTANT 60
          SA.LOD A.CMD-B..1        GET CORRECTLY SHIFTED X.WRD
          MX.FIX -W$FIXED        * MASK OF -W$FIXED 
          SA.GET A.LOD-B..1        X.SAV
          BX.WRD X.LOD           * CORRECTLY SHIFTED X.WRD
          BX.SAV X.GET           * X.SAV
 RESTORE  ENDM
  
COMPRESS  ELSE
  
 RESTORE  MACRO 
          RJ     RESTORE
 RESTORE  ENDM
  
 RESTORE  BSS    1
          SA.LOD B=LFTCNT          12/2000B+B.LFT, 48/B.CNT 
          SB..1  1               * CONSTANT 1 
          UX.TMP B.LFT,X.LOD     * B.LFT
          SA.GET A.LOD-B..1        GET A.WRD
          SB.CNT X.TMP           * B.CNT
          SA.WRD X.GET           * A.WRD
          SA.CMD A.GET-B..1      * CORRECTLY SHIFTED X.CMD
          SB..60 60              * CONSTANT 60
          SA.LOD A.CMD-B..1        GET CORRECTLY SHIFTED X.WRD
          MX.FIX -W$FIXED        * MASK OF -W$FIXED 
          SA.GET A.LOD-B..1        X.SAV
          BX.WRD X.LOD           * CORRECTLY SHIFTED X.WRD
          BX.SAV X.GET           * X.SAV
          EQ     RESTORE
  
COMPRESS  ENDIF 
RNC       SPACE  4,11 
**        RNC -  READ NEXT COMMAND
* 
*      CALLING FORM:  
*         RNC                      READ NEXT COMMAND
* 
*      DOES:  
*         FOR NON-DEBUG VERSION,
*             JUMPS TO *RNC* TO PREPARE FOR NEXT COMMAND
*         FOR DEBUG VERSION,
*             CONVERTS A.WRD, B.CNT AND B.LFT TO /INT/ADDR AND /INT/POS 
*             AND EXITS FROM *CGENINT*. 
  
  
1         IFEQ   DEBUGC,0          IF NON-DEBUG VERSION OF COMPILER 
  
 RNC      MACRO 
          RJ     ALIGN             PUT NEXT 60 COMMAND BITS INTO X.CMD
          LX.CMD W$C               RIGHT-JUSTIFY COMMAND OPCODE 
          SB.LFT B.LFT-W$C         DECREMENT NO. BITS LEFT IN X.CMD 
          MX.TMP -W$C 
          BX.TMP -X.TMP*X.CMD      EXTRACT COMMAND
          SB.TMP X.TMP
          JP     COMMANDL+B.TMP    GO EXECUTE COMMAND 
 RNC      ENDM
  
1         ELSE                     IF DEBUG VERSION OF COMPILER 
  
 RNC      MACRO 
          EQ     DEBUGRNC          GO SET /INT/ADDR AND /INT/POS
 RNC      ENDM
  
1         ENDIF 
SAVE      SPACE  4,9
**        SAVE -  SAVE REGISTERS NEEDED BY INTERPRETER
* 
*      CALLING FORM:  
*         SAVE
* 
*      DOES:  
*         SAVES COMMAND REGISTERS X.CMD, X.WRD, A.WRD, B.LFT, B.CNT.
*         SAVES SAVE REGISTER X.SAV.
*         LEAVES REGISTER B.TMP UNCHANGED.
  
  
COMPRESS  IF     -DEF,/COMPRESS/SAVE
  
 SAVE     MACRO 
          SA.SAV X=SAV             X.SAV
          BX.STO X.WRD
          LX.SAV X.CMD
          SA.STO A.SAV+B..1        X.WRD
          SA.SAV A.STO+B..1        X.CMD
          SX.STO B.CNT
          SX.SAV A.WRD
          PX.STO B.LFT,X.STO
          SA.SAV A.SAV+B..1        A.WRD
          SA.STO A.SAV+B..1        12/2000B+B.LFT,48/B.CNT
 SAVE     ENDM
  
COMPRESS  ELSE
  
 SAVE     MACRO 
          RJ     SAVE 
 SAVE     ENDM
 SAVE     BSS    1
          SA.SAV X=SAV             X.SAV
          BX.STO X.WRD
          LX.SAV X.CMD
          SA.STO A.SAV+B..1        X.WRD
          SA.SAV A.STO+B..1        X.CMD
          SX.STO B.CNT
          SX.SAV A.WRD
          PX.STO B.LFT,X.STO
          SA.SAV A.SAV+B..1        A.WRD
          SA.STO A.SAV+B..1        12/2000B+B.LFT,48/B.CNT
          EQ     SAVE 
  
COMPRESS  ENDIF 
SKIPADDR  SPACE  4,8
**        SKIPADDR -  SKIP ADDRESS IN COMMAND STREAM
* 
*      CALLING FORM:  
*         SKIPADDR                 SKIP ADDRESS IN COMMAND STRING 
* 
*      DOES:  
*         AFFECTS THE COMMAND STRING JUST AS *EVALADDR*,
*         EXCEPT FASTER.  IT DOES NOT SET X.TMP MEANINGFULLY. 
  
  
COMPRESS  IF     -DEF,/COMPRESS/SKIPADDR
  
1         IFEQ   DEBUGC,0          IF NON-DEBUG VERSION 
  
 SKIPADDR MACRO 
          LOCAL  NEXT,LONG
          NG     X.CMD,LONG 
          SB.LFT B.LFT-1-W$JUMP 
          LX.CMD 1+W$JUMP 
 NEXT     BSS    0
          USE    SKIPADR
 LONG     IX.TMP X.CMD+X.CMD       X.TMP \ 0 IFF ADDRESS IN SAME WORD 
          LX.CMD 1+18              SKIP ADDRESS 
          SB.LFT B.LFT-1-18        DECREMENT NO. BITS LEFT IN X.CMD 
          PL     X.TMP,NEXT        IF ADDRESS IN SAME WORD,  SKIP 
          SA.WRD A.WRD             UNSHIFT NEXT WORD
          SB.LFT 42 
          BX.CMD X.WRD
          SB.CNT B..0 
          LX.CMD 18                SKIP ADDRESS 
          EQ     NEXT 
          USE    *
 SKIPADDR ENDM
  
1         ELSE
  
 SKIPADDR OPSYN  EVALADDR          (SET BUG202C$JUMP = ADDRESS) 
  
1         ENDIF 
  
COMPRESS  ELSE
  
1         IFEQ   DEBUGC,0          IF NON-DEBUG VERSION 
  
 SKIPADDR MACRO 
          RJ     SKIPADDR 
 SKIPADDR ENDM
  
 SKIPADDR BSS    1
          NG     X.CMD,SKIPADD1 
          SB.LFT B.LFT-1-W$JUMP 
          LX.CMD 1+W$JUMP 
          EQ     SKIPADDR 
  
 SKIPADD1 IX.TMP X.CMD+X.CMD       X.TMP \ 0 IFF ADDRESS IN SAME WORD 
          LX.CMD 1+18              SKIP ADDRESS 
          SB.LFT B.LFT-1-18        DECREMENT NO. BITS LEFT IN X.CMD 
          PL     X.TMP,SKIPADDR    IF ADDRESS IN SAME WORD,  SKIP 
          SA.WRD A.WRD             UNSHIFT NEXT WORD
          SB.LFT 42 
          BX.CMD X.WRD
          SB.CNT B..0 
          LX.CMD 18                SKIP ADDRESS 
          EQ     SKIPADDR          DONE 
  
1         ELSE
  
 SKIPADDR OPSYN  EVALADDR          (SET BUG202C$JUMP = ADDRESS) 
  
1         ENDIF 
  
COMPRESS  ENDIF 
STORFUNC  SPACE  4,8
**        STORFUNC -  STORE X.STO ACCORDING TO FUNCTION 
* 
*      GIVEN: 
*         X.STO = VALUE TO BE STORED ACCORDING TO FUNCTION/FIXED CELL 
* 
*      DOES-
*         STORES IT.
*         PRESERVES X.SAV AND BACKGROUND REGISTERS. 
  
  
COMPRESS  IF     -DEF,/COMPRESS/STORFUNC
  
 STORFUNC MACRO 
          LOCAL  FUNC,NEXT
          NG     X.CMD,FUNC        IF FUNCTION
          LX.CMD 1+W$FIXED         RIGHT-JUSTIFY INDEX TO FIXED CELL
          BX.TMP -X.FIX*X.CMD      EXTRACT INDEX
          SB.LFT B.LFT-1-W$FIXED   DECREMENT NO. OF BITS LEFT IN X.CMD
          SA.STO FIXCELLS+X.TMP    STORE VALUE
1         $BEGIN
          SA.LOD /BUG202C/PTR 
          SA.STO /BUG202C/VFUN+X.LOD+1
          BX.STO X.TMP
          SA.STO /BUG202C/ARG+X.LOD+1 
          SX.STO X.LOD+B..1 
          SA.STO A.LOD
1         $END
 NEXT     BSS    0                 (RETURN FROM STORING INTO FUNCTION)
          USE    PUTFUNC
 FUNC     RJ     PUTFUNC           GO STORE X.STO ACCORDING TO FUNCTION 
          EQ     NEXT              RETURN TO CALLER 
          USE    *
 STORFUNC ENDM
  
COMPRESS  ELSE
  
 STORFUNC MACRO 
          RJ     STORFUNC 
 STORFUNC ENDM
  
 STORFUNC BSS    1
          NG     X.CMD,STORFUN1    IF FUNCTION
          LX.CMD 1+W$FIXED         RIGHT-JUSTIFY INDEX TO FIXED CELL
          BX.TMP -X.FIX*X.CMD      EXTRACT INDEX
          SB.LFT B.LFT-1-W$FIXED   DECREMENT NO. OF BITS LEFT IN X.CMD
          SA.STO FIXCELLS+X.TMP    STORE VALUE
1         $BEGIN
          SA.LOD /BUG202C/PTR 
          SA.STO /BUG202C/VFUN+X.LOD+1
          BX.STO X.TMP
          SA.STO /BUG202C/ARG+X.LOD+1 
          SX.STO X.LOD+B..1 
          SA.STO A.LOD
1         $END
          EQ     STORFUNC          DONE 
  
 STORFUN1 BSS    0
          SA.STO /INT/VFUN         STORE FOR *STOFUNC*
          LX.CMD 1+W$FUNC          RIGHT-JUSTIFY FUNCTION NUMBER
  
          ERRNZ  W$FUNC-W$FIXED  CHANGE NEXT INSTR.  "SEQUENCE" 
          BX.STO -X.FIX*X.CMD      EXTRACT FUNCTION ORDINAL 
  
          SA.STO /INT/FUN          STORE FOR *STOFUNC*
          LX.CMD W$FIXED           RIGHT-JUSTIFY PARAMETER
          SB.LFT B.LFT-1-W$FUNC-W$FIXED 
          BX.STO -X.FIX*X.CMD      EXTRACT PARAMETER
          SA.STO /INT/ARG          STORE FOR *STOFUNC*
          SA.LOD FIXCELLS+X.STO    LOAD FIXED CELL
          BX.STO X.LOD               (JUST IN CASE) 
          SA.STO /INT/VARG         STORE FOR *STOFUNC*  (MAYBE) 
  
          SAVE                     SAVE RELEVANT REGISTERS
          RJ     =X_STOFUNC        STORE VFUN 
  
1         IFEQ   DEBUGC,1          IF DEBUG VERSION OF COMPILER 
          SA.TMP /BUG202C/PTR      INDEX TO SAVED FUNCTIONS 
          SX.STO X.TMP+1           INCREMENT INDEX
          SA.STO A.TMP
          SA.LOD /INT/ARG          STACK INT$ARG
          SA.GET /INT/FUN          STACK INT$FUN
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/ARG+X.TMP+1 
          SA.SAV /BUG202C/FUN+X.TMP+1 
          SA.LOD /INT/VARG         STACK INT$VARG 
          SA.GET /INT/VFUN         STACK INT$VFUN 
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/VARG+X.TMP+1
          SA.SAV /BUG202C/VFUN+X.TMP+1
          SA.LOD /INT/VFIX         STACK INT$VFIX 
          SA.GET /INT/TABL         STACK INT$TABL 
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/VFIX+X.TMP+1
          SA.SAV /BUG202C/TABL+X.TMP+1
1         ENDIF 
  
          RESTORE                  RESTORE RELEVANT REGISTERS 
  
          EQ     STORFUNC          DONE 
  
COMPRESS  ENDIF 
STOROTXT  SPACE  4,8
**        STOROTXT -  STORE X.STO INTO OTXT BUFFER
* 
*      GIVEN: 
*         X.STO = VALUE TO BE STORED IN OTEXT BUFFER. 
* 
*      DOES-
*         STORES X.STO ACCORDING TO /OTXT/PTR.
*         INCREMENTS /OTXT/PTR BY 1.
  
  
 STOROTXT MACRO 
          SA.LOD /OTXT/PTR
          SA.STO /OTXT/WORD+X.LOD  STORE VALUE INTO OTEXT BUFFER
          SX.STO X.LOD+B..1 
          SA.STO A.LOD
 STOROTXT ENDM
XNC       SPACE  4,11 
**        XNC -  EXECUTE NEXT COMMAND 
* 
*      CALLING FORM:  
*         XNC                      EXECUTE NEXT COMMAND 
* 
*      DOES:  
*         FOR NON-DEBUG VERSION OF COMPILER,
*             ASSUMES X.CMD IS ALREADY SET WITH 60 UNUSED COMMAND BITS
*             AND EXECUTES IT.
*         FOR DEBUG VERSION OF COMPILER,
*             BEHAVES LIKE *RNC*. 
  
  
1         IFEQ   DEBUGC,0          IF NON-DEBUG VERSION OF COMPILER 
  
 XNC      MACRO 
          LX.CMD W$C               RIGHT-JUSTIFY COMMAND
          SB.LFT B.LFT-W$C         DECREMENT NO. BITS LEFT IN X.CMD 
          MX.TMP -W$C 
          BX.TMP -X.TMP*X.CMD      EXTRACT COMMAND
          SB.TMP X.TMP
          JP     COMMANDL+B.TMP    GO EXECUTE COMMAND 
 XNC      ENDM
  
1         ELSE                     IF DEBUG VERSION OF COMPILER 
  
 XNC      MACRO 
          NE     B.LFT,B..60,400000B+*
          EQ     DEBUGRNC 
 XNC      ENDM
  
1         ENDIF 
          TITLE  DATA DECLARATIONS
  
*      MISCELLANEOUS VARIABLES LOCAL TO CGENINT 
  
 OP1      BSS    1                 OPERAND 1
 OP2      BSS    1                 OPERAND 2
 TEMP     BSS    1                 TEMPORARY VALUE
 OPCODE   BSS    1
 NREGPS   BSS    1
 NSYMPS   BSS    1
 NCONPS   BSS    1
 NWORDS   BSS    1
  
*      USED BY *CALLZ* COMMAND
  
          $BEGIN
 DLIST1   CON    DMESS1 
 DMESS1   DATA   10HCGENINT-1 
          $END
  
*      USED BY SAVE/RESTORE MACROS
  
 X=SAV    BSS    1                                                     1
 X=WRD    BSS    1                                                     2
 X=CMD    BSS    1                                                     3
 A=WRD    BSS    1                                                     4
 B=LFTCNT BSS    1                 12/2000B+B.LFT, 48/B.CNT            5
  
  
*      USED BY *ALIGN* ROUTINE
  
 MASKTBL  BSS    0
 T1       SET    0
 T2       SET    60 
          DUP    61,3 
+         VFD    T1/-0,T2/0 
 T1       SET    T1+1 
 T2       SET    T2-1 
  
          NOREF  T1,T2
  
  
*      USED BY *EXECUTE* COMMAND
  
 PLIST1   CON    FIXCELLS+/FIXED/P1 
          CON    FIXCELLS+/FIXED/P2 
          CON    FIXCELLS+/FIXED/P3 
          CON    FIXCELLS+/FIXED/P4 
          CON    FIXCELLS+/FIXED/P5 
          CON    FIXCELLS+/FIXED/P6 
          CON    FIXCELLS+/FIXED/P7 
          CON    FIXCELLS+/FIXED/P8 
  
*      USED BY *ERROR* COMMAND
  
 PLIST2   CON    ERRNUM 
  
 ERRNUM   BSS    1
  
*      USED BY *NOTE* COMMAND 
  
DEBUGA    IFEQ   DEBUGA,1          IF *NOTE* CODE IS ASSEMBLED
 NOTEWRD1 VFD    12//OPNAMES/NOTED,16/0,14/1,18/2 
 NOTEWRD2 VFD    42/0,18/3H + 
 NOTEWRD3 VFD    12//OPNAMES/NOTED,16/0,14/1,18/1 
 NOTEWRD4 VFD    60/10H00000  = 
 NOTEWRD5 VFD    12//OPNAMES/NOTED,16/0,14/1,18/0 
 NOTEWRD6 VFD    48/0,12/2H 
DEBUGA    ENDIF 
/BUG202C/ EJECT 
**        /BUG202C/ -  DEBUG COMMUNICATION AREA FOR (20,2) OVERLAY
  
  
 #        OPSYN  NIL
  
 DEF      MACRO  QNAMVALQ 
 M1       MICRO  1,,QNAMVALQ
 M2       MICRO  1,,="M1" 
 T1       MICCNT M2 
 M3       MICRO  2+T1,,QNAMVALQ 
 "M2"     EQU    "M3" 
 DEF      ENDM
  
 COMMON   OPSYN  NIL
 ARRAY    MACRO  BNAM 
 M1       MICRO  1,9, BNAM
          IFC    NE, "M1" BUG202C$$ ,1
          ERR    ILLEGAL BUG202C ARRAY NAME (BNAM)  "SEQUENCE"
 M1       MICRO  10,, BNAM
          "M1"                     "SEQUENCE" 
 ARRAY    ENDM
  
 FLG      MACRO 
          BSS    2           [0:1] S(1) 
 FLG      ENDM
  
 LIM      MACRO 
          BSS    1+NFLG      [0:BUG202C$NFLG] S(1)
 LIM      ENDM
  
 FUN      MACRO 
          PURGMAC  ITEM 
 ITEM     MACRO  BNAME
 M1       MICRO  1,8, BNAME 
          IFC    NE, "M1" BUG202C$ ,1 
          ERR    ILLEGAL BUG202C ITEM NAME (BNAME)  "SEQUENCE"
 M1       MICRO  9,, BNAME
 "M1"     EQU    *-1
                    BSS    NFUN    [1:BUG202C$NFUN]  P( ) 
 ITEM     ENDM
 ENDDUM   MACRO 
          PURGMAC  ITEM 
 ITEM     MACRO  BNAME
 M1       MICRO  1,8, BNAME 
          IFC    NE, "M1" BUG202C$ ,1 
          ERR    ILLEGAL BUG202C ITEM NAME (BNAME)  "SEQUENCE"
 M1       MICRO  9,4, BNAME 
 "M1"           BSS    1
 ITEM     ENDM
 ENDDUM   ENDM
 END      OPSYN  ENDDUM 
 FUN      ENDM
  
 BEGIN    OPSYN  NIL
  
 ITEM     OPSYN  NIL
  
 .END     OPSYN  END
          PURGMAC  END
 END      OPSYN  NIL
  
  
  
  
          $BEGIN
  
          USE    /BUG202C/
          QUAL   BUG202C
  
          LIST   G
*CALL BUG202C 
  
          LIST   *
          QUAL   *
          USE    *
  
          $END
  
          PURGMAC  END
 END      OPSYN  .END 
  
          PURGMAC  #,DEF,COMMON,ARRAY,FLG,LIM,FUN,BEGIN,ITEM,ENDDUM 
COMMANDL  EJECT 
**        COMMANDL -  JUMP LIST FOR COMMANDS
* 
*      TYPICALLY: 
*         B.TMP = VALUE FROM COMMAND FIELD
*         JP     COMMANDL+B.TMP 
  
  
1         IF     -DEF,#COMMA
 ,        MACRO  NAME 
          COMMA  NAME 
 ,        ENDM
 #COMMA   EQU    0
1         ENDIF 
  
 COMMA    MACRO  NAME 
+         JP     NAME 
 COMMA    ENDM
  
 ;        OPSYN  NIL
  
  
  
  
 COMMANDL JP     400000B+*
*CALL COMMANDS
  
  
          PURGMAC  COMMA,;
FIXCELLS  EJECT 
**        FIXCELLS -  DEFINE COMMON BLOCK /FIXCOM/ FOR FIXED CELLS
* 
*      EXAMPLE: 
*         SA.LOD FIXCELLS+/FIXED/CURRLINE 
  
  
 #        OPSYN  NIL
  
*CALL     DEF 
  
*CALL     M$
  
          PURGMAC  COMMON 
 COMMON   MACRO  NAME 
          IFC    NE,;_NAME_FIXCOM;,1
          ERR    BLOCK SHOULD BE FIXCOM,  IS (NAME) 
 COMMON   ENDM
  
 ARRAY    MACRO  DIM
          IFC    NE, DIM [0:M$FIXED] ,1 
          ERR    DIMENSION SHOULD BE ([0:M$FIXED]),  IS (DIM) 
 FIXCELLS BSS    1+M$FIXED
 ARRAY    ENDM
  
 ITEM     OPSYN  NIL
  
  
  
  
          USE    /FIXCOM/ 
          LIST   G
*CALL FIXCOM
  
  
          LIST   *
          USE    *
  
          PURGMAC  #,COMMON,ARRAY,ITEM,STATUS 
/FIXED/   EJECT 
**        /FIXED/ -  DEFINE /FIXED/ SYMBOLS 
* 
*      ESPECIALLY:  
*         /FIXED/CURRLINE 
  
  
 #        OPSYN  NIL
  
  
  
 STATUS   MACRO  STATNAME 
 #STATNUM SET    0
 STATUS   ENDM
          SPACE  3
          IF     -DEF,#COMMA
 ,        MACRO  MNEMONIC 
          COMMA  MNEMONIC 
 ,        ENDM
          ENDIF 
          PURGMAC  COMMA
 COMMA    MACRO  MNEMONIC 
 #STATNUM SET    #STATNUM+1 
 MNEMONIC EQU    #STATNUM 
 COMMA    ENDM
          SPACE  3
 ;        OPSYN  NIL
  
  
  
  
          QUAL   FIXED
*CALL FIXED 
          QUAL   *
  
  
          SPACE  5
          QUAL   FUNCTION 
          STATUS FUNCTION 
*CALL FUNCTIONS 
          QUAL   *
/INT/     EJECT 
**        /INT/ -  DEFINE - /INT/ SYMBOLS 
* 
* 
  
  
 #        OPSYN  NIL
  
 COMMON   OPSYN  NIL
  
 BEGIN    OPSYN  NIL
  
 BASED    MACRO 
          BSS    1
 BASED    ENDM
  
          PURGMAC  ITEM 
 ITEM     MACRO  INTNAME
          IFC    NE, INTNAME COMMANDWORD ,5 
 M1       MICRO  1,4, INTNAME 
          IFC    NE, "M1" INT$ ,1 
          ERR    ILLEGAL INT$ ITEM (INTNAME)   "SEQUENCE" 
 M1       MICRO  5,8,/INTNAME       / 
 "M1"           BSS    1
          ENDM
  
 .END     OPSYN  END
 END      OPSYN  NIL
  
  
  
  
          USE    /INTCOM/ 
          QUAL   INT
          LIST   X,G
          SKIP   1                 (SKIP *CTEXT* CARD)
*CALL INT$
  
          LIST   *
          QUAL   *
          USE    *
  
          PURGMAC  END
 END      OPSYN  .END 
          PURGMAC  #,COMMAN,BEGIN,BASED,ITEM,.END 
/OPNAMES/ EJECT 
**        /OPNAMES/ -  DEFINE /OPNAMES/ SYMBOLS 
* 
*      ESPECIALLY:  
*         /OPNAMES/LOOP            (USED BY *GENLP*)
*         /OPNAMES/NOTED           (USED BY *NOTE*) 
*         /OPNAMES/OBJ             (USED BY *GENOBJ*) 
*         /OPNAMES/VFD$            (USED BY *GENVFD*) 
  
  
 #        OPSYN  NIL
  
 CONTROL  OPSYN  NIL
  
 NULL     OPSYN  NIL
  
  
          PURGMAC  STATUS,; 
          QUAL   OPNAMES
  
*CALL STATUS
  
  
  
  
*CALL OPNAMES 
  
          QUAL   *
  
  
          PURGMAC  #,CONTROL,NULL,DEF,STATUS,COMMA,;
/OTXT/    EJECT 
**        /OTXT/ -  DEFINE REFERENCES TO THE OTEXT BUFFER 
* 
*      DEFINES: 
*         /OTXT/LIM = VARIABLE CONTAINING SIZE OF BUFFER. 
*         /OTXT/PTR = INDEX TO NEXT AVAILABLE WORD IN BUFFER. 
*           (I.E. NEXT AVAILABLE WORD IS /OTXT/WORD + (/OTXT/PTR.)
*         /OTXT/WORD+0 IS THE FIRST WORD OF THE OTEXT BUFFER. 
  
  
          EXT    OTEXTWS
          EXT    WSLENGT
          EXT    WSLIMIT
  
          QUAL   OTXT 
  
 WORD     EQU    //OTEXTWS
 PTR      EQU    //WSLENGT
 LIM      EQU    //WSLIMIT
  
          QUAL   *
/PUSHPOP/ EJECT 
**        /PUSHPOP/ -  PUSH-POP STACK 
* 
*         CONTAINS /PUSHPOP/MAX ENTRIES.
* 
*         TOP OF STACK MAY BE REFERENCED BY 
*         SA.LOD /PUSHPOP/TOP 
*         SA.GET /PUSHPOP/STACK+X.LOD 
  
  
          QUAL   PUSHPOP
  
 MAX      EQU    100
  
 TOP      CON    0
  
 STACK    EQU    *-1
          BSS    MAX
  
          $BEGIN
 STACKORD EQU    *-1
          BSS    MAX
          $END
  
          QUAL   *
/STACK/   EJECT 
**        /STACK/ -  CALL/RETURN STACK
* 
*         CONTAINS /STACK/MAX ENTRIES 
* 
*         TOP OF STACK MAY BE REFERENCED BY:  
*         SA.LOD /STACK/PTR 
*         SA.GET /STACK/WORD_N+X.LOD
* 
* 
*      WORD0: 
*         12/2000B+B.LFT, 
*         18/MODADR,
*         12/2000B+B.CNT, 
*         18/A.WRD
* 
*      WORD1: 
*         60/X.CMD
* 
*      WORD2: 
*         60/X.WRD           (PROPERLY SHIFTED) 
* 
*      WORD3: 
*         42/EGO NAME        (DEBUG VERSION ONLY) 
*         18/EGO ADDRESS     (DEBUG VERSION ONLY) 
  
  
          QUAL   STACK
  
 MAX      EQU    20 
  
 PTR      CON    0
  
 WORD0    EQU    *-1
          BSS    MAX
  
 WORD1    EQU    *-1
          BSS    MAX
  
 WORD2    EQU    *-1
          BSS    MAX
  
          $BEGIN
 WORD3    EQU    *-1
          BSS    MAX
          $END
  
          QUAL   *
SUBCOML   EJECT 
**        SUBCOML -  JUMP LIST FOR SUBCOMMANDS
* 
*      TYPICALLY: 
*         B.TMP = VALUE FROM SUB-COMMAND FIELD
*         JP     SUBCOML+B.TMP
  
  
1         IF     -DEF,#COMMA
 ,        MACRO  NAME 
          COMMA  NAME 
 ,        ENDM
 #COMMA   EQU    0
1         ENDIF 
  
 COMMA    MACRO  NAME 
+         JP     NAME 
 COMMA    ENDM
  
 ;        OPSYN  NIL
  
  
  
  
 SUBCOML  JP     400000B+*
*CALL SUBCOMS 
  
  
          PURGMAC  COMMA,;
W$        EJECT 
**        W$ -  DEFINE WIDTHS OF FIELDS 
* 
*      DEFINES: 
*         W$C 
*         W$FIXED 
*         W$FUNC
*         W$OPNAME
  
  
 #        OPSYN  NIL
  
*CALL DEF 
  
          SKIP   1                 (SKIP *CTEXT* CARD)
*CALL W$
  
 FUNC     EQU    1+W$FUNC+W$FIXED 
 ADDR     EQU    1+17+18     1/1, 17/-0, NEW WORD, 18/ADDRESS 
          TITLE  MAIN LOOP
  
*      BEGIN EXECUTION
  
          ENTRY  CGENINT
 CGENINT  BSS    1                 ENTRY/EXIT WORD
          SB..1  1
          SB..60 60                SET CONSTANT 60
          MX.FIX -W$FIXED          SET CONSTANT MASK
          SA.LOD /INT/ADDR
          SA.GET /INT/POS 
          SA.WRD X.LOD
          SB.TMP X.GET
          SB.CNT B..60-B.TMP
          LX.WRD X.WRD,B.TMP
          SB.LFT B..0 
  
*      PUT NEXT 60 COMMAND BITS INTO X.CMD
  
          RJ     ALIGN
  
*      EXECUTE NEXT COMMAND 
  
          MX.TMP -W$C 
          LX.CMD W$C               RIGHT-JUSTIFY COMMAND OPCODE 
          SB.LFT B.LFT-W$C         DECREMENT NO. BITS LEFT IN X.CMD 
          BX.TMP -X.TMP*X.CMD      EXTRACT COMMAND
          SB.TMP X.TMP
  
          $BEGIN
          SA.LOD /INT/ADDR         SET BUG202C$ADDR = INT$ADDR
          SA.GET /INT/POS          SET BUG202C$POS = INT$POS
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/ADDR
          SA.SAV /BUG202C/POS 
          SX.STO B.TMP+0           SET BUG202C$OP = OPCODE
          SA.STO /BUG202C/OP
          SX.STO 0
          SA.STO /BUG202C/PTR 
          $END
  
          JP     COMMANDL+B.TMP    GO EXECUTE COMMAND 
          TITLE  COMMANDS 
ADDZ      SPACE  4
**        ADDZ -  ADD FUNC1 TO FUNC2 GIVING FUNC3 
* 
*      COMMAND: 
*         FUNCTION1,
*         FUNCTION2,
*         FUNCTION3 
* 
*      DOES:  
*         COMPUTES FUNCTION3 = FUNCTION1 + FUNCTION 2.
  
  
 ADDZ     EVALFUNC                 SET X.TMP = VALUE OF FUNCTION
          BX.SAV X.TMP             PRESERVE THE VALUE 
          EVALFUNC                 SET X.TMP = VALUE OF FUNCTION
          IX.STO X.SAV+X.TMP       ADD
          STORFUNC                 STORE RESULT 
          CMD@60 W$C+FUNC+FUNC+FUNC,(FUNC)
          RNC                      READ NEXT COMMAND
ANDZ      SPACE  4
**        ANDZ/MINZ -  COMPUTE MINIMUM OF TWO VALUES
* 
*      COMMAND: 
*         FUNCTION1,
*         FUNCTION2,
*         FUNCTION3 
* 
*      DOES:  
*         SETS FUNCTION3 = MINIMUM(FUNCTION1, FUNCTION2)
  
  
 ANDZ     EVALFUNC                 SET X.TMP = VALUE OF FUNCTION
          BX.SAV X.TMP             PRESERVE VALUE 
          EVALFUNC                 SET X.TMP = VALUE OF FUNCTION
          BX.STO X.SAV             ASSUME FUNCTION1 IS SMALLER
          IX.LOD X.SAV-X.TMP
          NG     X.LOD,ANDZ1       IF FUNCTION1 < FUNCTION2 
          BX.STO X.TMP             FUNCTION2 IS SMALLER 
 ANDZ1    BSS    0                 X.STO IS SMALLEST VALUE
          STORFUNC                 STORE VALUE INTO FUNCTION3 
          RNC                      READ NEXT COMMAND
BRANCH    SPACE  4
**        BRANCH -  BRANCH TO SPECIFIED ADDRESS 
* 
*      COMMAND: 
*         ADDRESS 
* 
*      DOES:  
*         CAUSES INTERPRETATION TO CONTINUE FROM SPECIFIED ADDRESS. 
  
  
 BRANCH   EVALADDR                 SET X.TMP = ADDRESS
          ZR     X.TMP,RETURNZ     IF *RETURN* WAS SPECIFIED
          SA.WRD X.TMP             START AT NEW ADDRESS 
          BX.CMD X.WRD             X.WRD = NEXT 60 COMMAND BITS 
          SB.LFT B..60             NOTE 60 BITS IN X.CMD
          SB.CNT B..0              NOTE NO BITS IN X.WRD
          XNC                      EXECUTE NEXT COMMAND 
CALLZ     SPACE  4
**        CALLZ -  CALL AN INTERPRETIVE SUBROUTINE
* 
*      COMMAND: 
*         ADDRESS 
* 
*      DOES:  
*         INCREMENTS THE STACK POINTER. 
*         IF DEBUG VERSION, 
*            SAVES NAME AND ADDRESS OF LAST-EXECUTED EGO COMMAND. 
*         IF STACK OVERFLOW,
*            PRINTS A DIAGNOSTIC. 
*         STACKS A.WRD, X.WRD, X.CMD, B.CNT AND B.LFT.
*         CONTINUES INTERPRETATION AT SPECIFIED ADDRESS.
  
  
 CALLZ    SA.LOD /STACK/PTR        INCREMENT STACK POINTER
          SX.SAV X.LOD+B..1 
          SA.SAV A.LOD
  
*      IF STACK OVERFLOW,  PRINT A DIAGNOSTIC 
  
          $BEGIN
          SA.SAV /BUG202C/SPTR     SAVE FOR TRACE 
          SB.TMP X.SAV-/STACK/MAX 
          LE     B.TMP,B..0,CALLZ1 IF NO STACK OVERFLOW,  SKIP
              SAVE                     SAVE RELEVANT REGISTERS
              SA1    DLIST1            (CGENINT-1)
              RJ     =X_CGABORT        PRINT DIAGNOSTIC 
              RESTORE                  RESTORE RELEVANT REGISTERS 
 CALLZ1       BSS    0
          $END
  
*      EVALUATE AND SAVE ADDRESS
  
          EVALADDR                 SET X.TMP = ADDRESS
  
*      STACK A.WRD, X.WRD, X.CMD, B.CNT AND B.LFT.
  
          SA.LOD /INT/MODADR       ADDRESS OF THIS MODULE 
          PX.STO B.CNT,X.LOD
          LX.STO 30 
          SX.GET A.WRD
          PX.GET B.LFT,X.GET
          BX.STO X.GET+X.STO
          SA.STO /STACK/WORD0+X.SAV 
          BX.STO X.CMD
          SA.STO /STACK/WORD1+X.SAV 
          BX.STO X.WRD
          SA.STO /STACK/WORD2+X.SAV 
  
*      IF DEBUG VERSION,  SAVE NAME AND ADDRESS OF LAST-EXECUTED EGO
  
          $BEGIN
          SA.SAV /BUG202C/PTR 
          SA.LOD /BUG202C/EGNM     42/0H_EGONAME
          MX.GET 7*6
          BX.STO X.GET*X.LOD
          SA.LOD /BUG202C/EGAD     ADDRESS OF EGO COMMAND 
          BX.STO X.STO+X.LOD
          SA.STO /STACK/WORD3+X.SAV 
          $END
  
*      CONTINUE INTERPRETATION AT SPECIFIED ADDRESS 
  
          SA.WRD X.TMP
          SB.CNT B..0 
          BX.CMD X.WRD
          SB.LFT B..60
          XNC                      EXECUTE NEXT COMMAND 
EGO       SPACE  4
**        EGO -  DECLARE ADDRESS OF MODULE
* 
*      COMMAND: 
*         18/ADDRESS OF MODULE, 
*         4/LEVEL,           (DEBUG ONLY) 
*         4/N                (DEBUG ONLY) 
*         6*N/NAME           (DEBUG ONLY) 
* 
*      DOES:  
* 
  
  
 EGO      BSS    0
  
*      SAVE MODULE ADDRESS FOR LATER *SETSYOF* AND *CONSTOF* FUNCTIONS
  
          LX.CMD 18                RIGHT-JUSTIFY MODULE ADDRESS 
          SB.LFT B.LFT-18          DECREMENT NO. BITS LEFT IN X.CMD 
          SX.STO X.CMD             EXTRACT AND STORE MODULE ADDRESS 
          SA.STO /INT/MODADR
  
*      EXTRACT AND SAVE EGO NAME AND ADDRESS
  
          $BEGIN
          RJ     ALIGN             ENSURE ROOM FOR 8-CHARACTER NAME 
          LX.CMD 4                 RIGHT-JUSTIFY EGO LEVEL
          SB.LFT B.LFT-4           DECREMENT NO. BITS LEFT IN X.CMD 
          MX.TMP -4 
          BX.STO -X.TMP*X.CMD      EXTRACT EGO LEVEL
          SA.STO /BUG202C/VFUN+1
  
          SX.STO 1
          SA.STO /BUG202C/PTR      REMEMBER TO CLEAR LEVEL
  
          SX.STO A.WRD
          SA.STO /BUG202C/EGAD     LATEST EGO ADDRESS 
  
          LX.CMD 4                 RIGHT-JUSTIFY NO. OF CHARACTERS
          SB.LFT B.LFT-4
          BX.TMP -X.TMP*X.CMD      NO. OF CHARACTERS
          SB.TMP X.TMP             1*N
          SB.SCR B.TMP+B.TMP       2*N
          SB.TMP B.SCR+B.SCR       4*N
          SB.TMP B.TMP+B.SCR       6*N
          SB.LFT B.LFT-B.TMP       DECREMENT BITS LEFT IN X.CMD 
          MX.TMP 1
          SB.SCR B.TMP-B..1 
          AX.TMP X.TMP,B.SCR       FORM MASK TO EXTRACT NAME
          BX.STO X.TMP*X.CMD       EXTRACT NAME 
          SA.LOD =10H 
          LX.CMD X.CMD,B.TMP       SKIP EGO NAME
          BX.TMP -X.TMP*X.LOD      BLANK-FILL 
          IX.STO X.STO+X.TMP
          SA.STO /BUG202C/EGNM     SAVE NAME
          $END
  
          RNC                      READ NEXT COMMAND
EQZ       SPACE  4
**        EQZ -  CHECK FOR EQUALITY BETWEEN VALUES
* 
*      COMMAND: 
*         FUNCTION1,
*         FUNCTION2,
*         FUNCTION3 
* 
*      DOES:  
*         IF FUNCTION1 = FUNCTION2, 
*             SETS FUNCTION3 = 1
*         ELSE
*             SETS FUNCTION3 = 0. 
  
  
 EQZ      EVALFUNC                 SET X.TMP = VALUE OF FUNCTION
          BX.SAV X.TMP             PRESERVE VALUE 
          EVALFUNC                 SET X.TMP = VALUE OF FUNCTION
          IX.LOD X.SAV-X.TMP
          SX.STO B..0              ASSUME VALUES ARE UNEQUAL
          NZ     X.LOD,EQZ1        IF VALUES ARE UNEQUAL,  SKIP 
          SX.STO B..1              NOTE THAT VALUES ARE EQUAL 
 EQZ1     BSS    0                 (X.STO IS PROPERLY SET HERE) 
          STORFUNC                 STORE X.STO INTO FUNCTION
          RNC                      READ NEXT COMMAND
ERROR     SPACE  4
**        ERROR -  PRINT A DIAGNOSTIC 
* 
*      COMMAND: 
*         15/ERRNUM 
  
  
 ERROR    BSS    0
          LX.CMD 15                RIGHT-JUSTIFY ERROR NUMBER 
          SB.LFT B.LFT-15 
          MX.TMP -15
          BX.STO -X.TMP*X.CMD      EXTRACT ERROR NUMBER 
          SA.STO ERRNUM 
          SAVE                     SAVE RELEVANT REGISTERS
          SA1    PLIST2            PARAMETER IS (ERRNUM)
          RJ     =X_DEC            SET X6 = ERROR NUMBER (DECIMAL)
          SA6    ERRNUM            PREPARE AS PARAMETER FOR *CGABORT* 
          SA1    PLIST2            PARAMETER IS (ERRNUM)
          RJ     =X_CGABORT        PRINT ERROR LINE 
          RESTORE                  RESTORE RELEVANT REGISTERS 
          RNC                      READ NEXT COMMAND
EXECUTE   SPACE  4
**        EXECUTE -  EXECUTE MACHINE LANGUAGE SUBROUTINE
* 
*      COMMAND: 
*         ADDRESS,
*         4/N,               (DEBUG ONLY) 
*         6*N/NAME           (DEBUG ONLY) 
* 
*      DOES:  
*         EXECUTES SPECIFIED SUBROUTINE WITH FIXED CELLS P1, P2, P3, P4 
*            AS PARAMETERS. 
  
  
 EXECUTE  EVALADDR                 SET X.TMP = ADDRESS
  
*      SAVE SUBROUTINE NAME AND ADDRESS 
  
          $BEGIN
          BX.SAV X.TMP             SAVE ADDRESS 
          RJ     ALIGN             ENSURE FULL NAME IN X.CMD
          LX.CMD 4                 RIGHT-JUSTIFY CHARACTER COUNT
          SB.LFT B.LFT-4
          MX.TMP -4 
          BX.TMP -X.TMP*X.CMD      EXTRACT CHARACTER COUNT
          SB.TMP X.TMP             1*N
          SB.SCR B.TMP+B.TMP       2*N
          SB.TMP B.SCR+B.SCR       4*N
          SB.TMP B.TMP+B.SCR       6*N
          SB.LFT B.LFT-B.TMP       DECREMENT BITS LEFT IN X.CMD 
          MX.TMP 1
          SB.SCR B.TMP-B..1 
          AX.TMP X.TMP,B.SCR       FORM MASK
          BX.STO X.TMP*X.CMD       EXTRACT NAME 
          SA.LOD =10H 
          BX.LOD -X.TMP*X.LOD 
          IX.STO X.STO+X.LOD
          SA.STO /BUG202C/VFUN+1   SAVE NAME
          SA.SAV /BUG202C/VARG+1   SAVE ADDRESS 
          LX.CMD X.CMD,B.TMP       SKIP NAME
          BX.TMP X.SAV             RESTORE ADDRESS OF SUBROUTINE
          $END
  
*      CALL THE SUBROUTINE
  
          SB.TMP X.TMP
          SAVE                     PRESERVE RELEVANT REGISTERS
*         B.TMP IS UNCHANGED
          SA.LOD EXECUTE2          LOAD RETURN INSTRUCTION
          BX.STO X.LOD
          SA.STO B.TMP
          SA1    PLIST1            (P1,P2,P3,P4)
          JP     B.TMP+1
  
*      AFTER EXECUTION,  RESTORE REGISTERS AND RESUME INTERPRETATION
  
 EXECUTE1 RESTORE                  RESTORE RELEVANT REGISTERS 
          RNC                      READ NEXT COMMAND
  
  
 EXECUTE2 JP     EXECUTE1          (EXIT INTRUCTION FROM SUBROUTINE)
FORCEUP   SPACE  4
**        FORCEUP -  FORCE INTERPRETATION TO START OF NEXT WORD 
* 
*      COMMAND: 
*         (NONE)
* 
*      DOES:  
*         CONTINUES INTERPRETATION STARTING FROM THE NEXT WORD
*           BOUNDARY. 
* 
*         THIS COMMAND USUALLY PRECEDES A *LABEL* DECLARATION.
  
  
 FORCEUP  SB.TMP B..60-B.LFT       BITS USED BY *FORCEUP* OPCDOE
          GE     B.CNT,B.TMP,FORCEUP1 
          SA.WRD A.WRD+B..1 
 FORCEUP1 SA.WRD A.WRD             UNSHIFT WORD WITH NEXT COMMAND 
          BX.CMD X.WRD
          SB.LFT B..60
          SB.CNT B..0 
          XNC                      EXECUTE NEXT COMMAND 
GENLP     SPACE  4
**        GENLP -  GENERATE INFORMATION FOR LOOP
* 
*      COMMAND: 
*         4/N,               NUMBER OF FUNCTIONS FOLLOWING
*         FUNCTION, 
*         ...                (TOTAL OF *N* FUNCTIONS) 
*         FUNCTION
* 
*      OTEXT= 
*         12/OPCODE,         (DOPCODE FROM COMDECK INSTDEFS)
*         16/0, 
*         14/NWORDS,         (ACTUALLY DCOUNT FROM COMDECK INSTDEFS)
*         18/0
* 
*         18/FUNCTION1, 
*         18/FUNCTION2, 
*         18/FUNCTION3, 
*         6/0 
* 
*         ... 
  
  
 GENLP    LX.CMD 4                 RIGHT-JUSTIFY NUMBER OF FUNCTIONS
          SB.LFT B.LFT-4
          MX.TMP -4 
          BX.STO -X.TMP*X.CMD      EXTRACT NUMBER OF FUNCTIONS
          SA.STO NREGPS            SAVE 
  
          SX.TMP X.STO+2+3
          SX.STO 1S18/3+1          1/3 * 2'18 
          IX.SAV X.TMP*X.STO       ( (NREGPS+2)/3 + 1) * 2'18 
          AX.SAV 18                (NREGPS+2)/3 + 1 
          BX.TMP X.SAV
          CHECKOT                  ENSURE X.TMP WORDS IN OTEXT BUFFER 
  
          SX.STO X.SAV-1           SET NO. OF FOLLOWING WORDS 
          LX.STO 18                  IN U(0,28,14)
  
*      SET  DOPCODE # U(0,0,12)  TO OPNAMES"LOOP" 
  
          SX.TMP /OPNAMES/LOOP
          LX.TMP 48 
          BX.STO X.TMP+X.STO
  
*      STORE INTO OTEXT BUFFER
  
          STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
*      APPEND FUNCTION PARAMETERS 
          SA.LOD NREGPS 
          RJ     WRITEFUN 
  
          RNC                      READ NEXT COMMAND
GENM      SPACE  4
**        GENM -  GENERATE OBJECT MACRO CALLING SEQUENCE
* 
*      COMMAND: 
* 
*         12/MACRO NUMBER + MACOFF
*         4/NUMBER OF *SYMP* PARAMETERS,
*         4/NUMBER OF *REGP* PARAMETERS,
*         4/NUMBER OF *CONP* PARAMETERS,
*         *SYMP* PARAMETERS,
*         *REGP* PARAMETERS,
*         *CONP* PARAMETERS 
* 
*      OTEXT= 
*         12/MACNUM+MACOFF   (DOPCODE FROM COMDECK INSTDEFS)
*         16/0, 
*         14/NUMBER OF WORDS OF PARAMETERS, 
*                            (DCOUNT FROM COMDECK INSTDEFS) 
*         18/0
* 
*         *SYMP* PARAMETERS 
* 
*         *REGP* PARAMETERS 
* 
*         *CONP* PARAMETERS 
  
  
 GENM     LX.CMD 12                RIGHT-JUSTIFY MACNUM + MACOFF
          MX.TMP -12
          BX.SAV -X.TMP*X.CMD      PRESERVE MACNUM+MACOFF 
  
          LX.CMD 4
          MX.GET -4 
          BX.STO -X.GET*X.CMD 
          SA.STO NSYMPS 
          BX.TMP X.STO
  
          LX.CMD 4
          BX.STO -X.GET*X.CMD 
          SA.STO NREGPS 
          SX.LOD 1S18/3+1          1/3 * 2'18 
          SX.STO X.STO+2
          IX.STO X.STO*X.LOD       (NREGPS+2)/3 * 2'18
          AX.STO 18                (NREGPS+2)/3 
          IX.TMP X.TMP+X.STO       NSYMPS + (NREGPS+2)/3
  
          LX.CMD 4
          BX.STO -X.GET*X.CMD 
          SA.STO NCONPS 
          SX.STO X.STO+2
          IX.STO X.STO*X.LOD
          AX.STO 18                (NCONPS+2)/3 
          IX.TMP X.TMP+X.STO       NSYMPS + (NREGPS+2)/3 + (NCONPS+2)/3 
  
          SB.LFT B.LFT-12-4-4-4 
          BX.STO X.TMP
          SA.STO NWORDS 
  
          CHECKOT                  ENSURE X.TMP WORDS IN OTEXT BUFFER 
  
*      STORE HEADER WORD INTO OTEXT BUFFER
  
          LX.SAV 48                DOPCODE IN U(0,0,12) 
          SA.LOD NWORDS 
          LX.LOD 18                DCOUNT IN U(0,28,14) 
          BX.STO X.SAV+X.LOD
          STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
*      STORE SYMBOLIC PARAMETERS
  
          SA.LOD NSYMPS 
          BX.SAV X.LOD
 GENM1    ZR     X.SAV,GENM2       IF NONE LEFT,  SKIP
          RJ     ALIGN             ENSURE 60 COMMAND BITS 
          SX.STO 0                 ENSURE NO TABL REF IF FIXED CELL 
          SA.STO /INT/TABL
          EVALFUNC                 SET X.TMP = VALUE OF FUNCTION
          MX.GET -18               ALLOW NEGATIVE SUBSCRIPT OFFSET
          BX.TMP -X.GET*X.TMP 
          LX.TMP 30                CONS IN I(0,12,18) 
          SA.LOD /INT/TABL
          BX.STO X.TMP+X.LOD       TABL IN U(0,30,30) 
          STOROTXT                 STORE X.STO INTO OTEXT BUFFER
          SX.SAV X.SAV-1           DECREMENT COUNT OF SYMP PARAMETERS 
          EQ     GENM1             TRY FOR NEXT PARAMETER 
  
  
*      STORE REGISTER PARAMETERS
  
 GENM2    SA.LOD NREGPS 
          RJ     WRITEFUN 
  
*      STORE CONSTANT PARAMETERS INTO OTEXT 
  
          SA.LOD NCONPS 
          RJ     WRITEFUN 
  
          RNC                      READ NEXT COMMAND
GENOBJ    SPACE  4
**        GENOBJ -  GENERATE CALL TO OBJECT-TIME ROUTINE
* 
*      COMMAND: 
*         W$OBJNAM/<ORDINAL OF OBJECT-TIME ROUTINE>,
*       * 1/0                (IF NO MODIFIER) 
*       * 1/1,W$FIXED/M      (IF MODIFIER)
*         1/BREG,            = 1 IFF LINKAGE IS BY B-REGISTER 
*         4/IREG,            NUMBER OF INPUT REGISTERS
*         4/OREG             NUMBER OF OUTPUT REGISTERS 
*         4/OREG,            NUMBER OF OUTPUT REGISTERS 
*         FUNCTIONS,         TO GET V.R.N.S FOR INPUT REGISTERS 
*         FUNCTIONS          TO GET V.R.N.S FOR OUTPUT REGISTERS
* 
*      OTEXT= 
*         12/OPCODE,         (DOPCODE FROM COMDECK INSTDEFS)
*         16/0, 
*         14/NWORDS,         (DCOUNT FROM COMDECK INSTDEFS) 
*         18/0
* 
*         18/<(MODIFIED) ORDINAL OF OBJECT-TIME ROUTINE>, 
*         18/<CURRENT LINE NUMBER>, 
*         18/<NEXT LOCAL LABEL NUMBER>,   (IF LINKAGE BY B-REGISTER)
*         6/0 
* 
*         ...                VIRTUAL REGISTER NUMBERS OF INPUT REGISTERS
* 
*         ...                VIRTUAL REGISTER NUMBERS OF OUTPUT REGS. 
  
  
 GENOBJ   BSS    0
  
*      SET X.SAV = (MODIFIED) ORDINAL OF OBJECT-TIME ROUTINE
  
          LX.CMD W$OBJNAM          RIGHT-JUSTIFY ORDINAL
          MX.TMP -W$OBJNAM
          BX.STO -X.TMP*X.CMD      EXTRACT BASIC ORDINAL
          BX.TMP X.CMD             SIGN BIT INDICATES MODIFICATION
          SB.LFT B.LFT-W$OBJNAM-1  DECREMENT NO. OF BITS LEFT IN X.CMD
          LX.CMD 1                 SKIP MODIFICATION BIT
          PL     X.TMP,GENOBJ1     IF NO MODIFICATION,  SKIP
  
          LX.CMD W$FIXED           RIGHT-JUSTIFY INDEX TO FIXED CELL
          SB.LFT B.LFT-W$FIXED     DECREMENT NO. OF BITS LEFT IN X.CMD
          BX.TMP -X.FIX*X.CMD      EXTRACT INDEX
          SA.LOD FIXCELLS+X.TMP    LOAD VALUE OF FIXED CELL 
          IX.STO X.STO+X.LOD       MODIFY ORDINAL 
 GENOBJ1  SA.STO OPCODE            SAVE FINAL ORDINAL 
  
*      EXTRACT REMAINING PARAMETERS 
  
          BX.STO X.CMD             SIGN BIT INDICATES B-REGISTER LINKAGE
          SA.STO TEMP 
          LX.CMD 1+4               RIGHT-JUSTIFY NO. OF INPUT REGISTERS 
          MX.TMP -4 
          BX.STO -X.TMP*X.CMD      EXTRACT NO. OF INPUT REGISTERS 
          SA.STO OP1
          SX.LOD 1S18/3+1          1/3 * 2'18 
          SX.STO X.STO+2
          IX.SAV X.STO*X.LOD       (OP1+2)/3 * 2'18 
          AX.SAV 18 
          LX.CMD 4                 RIGHT-JUSTIFY NO. OUTPUT REGISTERS 
          SB.LFT B.LFT-1-4-4       DECREMENT NO. BITS LEFT IN X.CMD 
          BX.STO -X.TMP*X.CMD      EXTRACT NO. OF OUTPUT REGISTERS
          SA.STO OP2
          SX.STO X.STO+2           OP2 + 2
          IX.GET X.STO*X.LOD       ( (OP2+2)/3 ) * 2'18 
          AX.GET 18                (OP2+2)/3
          IX.TMP X.SAV+X.GET       (OP1+2)/3 + (OP2+2)/3
          SX.LOD X.TMP+B..1        1 + (OP1+2)/3 + (OP2+2)/3
          SX.STO /OPNAMES/OBJ 
          LX.STO 48                DOPCODE IN U(0,0,12) 
          SX.TMP X.LOD+B..1        INCLUDE HEADER WORD IN OTEXT DEMAND
          LX.LOD 18                DCOUNT IN U(0,28,14) 
          BX.SAV X.STO+X.LOD       FIRST OTEXT WORD 
          CMD@60 W$C+W$FIXED+1+4+4
  
*      ENSURE ENOUGH ROOM IN OTEXT BUFFER 
  
          CHECKOT                  ENSURE X.TMP WORDS IN OTEXT BUFFER 
  
*      STORE FIRST OTEXT WORD 
  
          BX.STO X.SAV
          STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
*      SET UP AND STORE SECOND OTEXT WORD 
  
          SX.STO B..0 
          SA.LOD TEMP              NEGATIVE IFF B-REGISTER LINKAGE
          PL     X.LOD,GENOBJ2     IF NO B-REG LINK,  SKIP
              SAVE                     SAVE RELEVANT REGISTERS
              RJ     =X_NEXTLAB        SET X6 = NEXT LOCAL LABEL NO.
              SA6    TEMP              SAVE RESULT
              RESTORE                  RESTORE RELEVANT REGISTERS 
              SA.LOD TEMP              PICK UP RESULT 
              BX.STO X.LOD
              LX.STO 6                 (X6 IS X.STO)
 GENOBJ2      BSS    0             (X.STO HAS U(0,36,18) ALREADY SET) 
          SA.LOD OPCODE            (MODIFIED) ORDINAL OF ROUTINE
          LX.LOD 42                IN U(0,0,18) 
          BX.STO X.STO+X.LOD
          SA.GET FIXCELLS+/FIXED/CURRLINE 
          LX.GET 24                IN U(0,18,18)
          BX.STO X.STO+X.GET
          STOROTXT                 STORE INTO OTEXT BUFFER
  
*      WRITE INPUT VIRTUAL REGISTER NUMBERS TO OTEXT
  
          SA.LOD OP1               NO. OF INPUT REGISTERS 
          RJ     WRITEFUN 
  
*      WRITE OUTPUT VIRTUAL REGISTERS TO OTEXT BUFFER 
  
          SA.LOD OP2               NO. OF OUTPUT REGISTERS
          RJ     WRITEFUN 
  
          RNC                      READ NEXT COMMAND
GENREPL   SPACE  4
**        GENREPL -  GENERATE REPLICATION TABLE 
  
 GENREPL  JP     400000B+*
GENVFD    SPACE  4
**        GENVFD -  GENERATE VFD DATA ITEMS 
* 
*      COMMAND: 
*         W$VFD/NPAIRS, 
*         FUNCTION1W,        (WIDTH OF VFD FIELD) 
*         FUNCTION1V,        (VALUE OF VFD FIELD) 
*         ...                (*NPAIRS* TIMES) 
* 
*      OTEXT= 
*         12/OPCODE,         (DOPCODE FROM COMDECK INSTDEFS)
*         16/0, 
*         14/2*NPAIRS,       (DCOUNT FROM COMDECK INSTDEFS) 
*         18/0
* 
*         12/NBITS,          (DNUM FROM COMDECK INSTDEFS) 
*         18/0, 
*         4/MOD, 8/TABLE, 18/INDEX
*                            (DTABL FROM COMDECK INSTDEFS)
* 
*         60/CONSTANT        (DTEXT FROM COMDECK INSTDEFS)
* 
*         ... 
  
  
 GENVFD   LX.CMD W$VFD             RIGHT-JUSTIFY NO. OF FIELDS
          SB.LFT B.LFT-W$VFD       DECREMENT NO. BITS LEFT IN X.CMD 
          MX.TMP -W$VFD 
          BX.SAV -X.TMP*X.CMD      EXTRACT NO. OF FIELDS
          IX.SAV X.SAV+X.SAV       2*NPAIRS 
          SX.TMP X.SAV+B..1        ENSURE X.TMP WORDS IN OTEXT BUFFER 
          CHECKOT 
  
*      STORE FIRST WORD OF OTEXT
  
          SX.STO /OPNAMES/VFD$
          LX.STO 48                DOPCODE IS U(0,0,12) 
          LX.SAV 18                DCOUNT IS U(0,28,14) 
          BX.STO X.STO+X.SAV
          STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
*      PROCESS EACH FIELD 
  
          AX.SAV 18+1              NPAIRS 
  
 GENVFD1      SA.SAV TEMP              SAVE NPAIRS
              RJ     ALIGN             ENSURE 60 COMMAND BITS 
              EVALFUNC                 SET X.TMP = VALUE
              BX.SAV X.TMP             PRESERVE VALUE 
          SX.STO 0                 ENSURE NO TABL REF IF FIXED CELL 
          SA.STO /INT/TABL
              EVALFUNC                 SET X.TMP = VALUE
              LX.SAV 48                DNUM IS U(0,0,12)
              SA.LOD /INT/TABL         4/MOD, 8/TABLE, 18/INDEX 
              BX.STO X.SAV+X.LOD       FIRST OF OTEXT PAIR
              BX.SAV X.TMP             PRESERVE VALUE 
              STOROTXT                 STORE INTO OTEXT BUFFER
              BX.STO X.SAV             VALUE
              STOROTXT                 STORE INTO OTEXT BUFFER
              SA.LOD TEMP              NPAIRS 
              SX.SAV X.LOD-1           DECREMENT NPAIRS BY 1
              NZ     X.SAV,GENVFD1     IN MORE PAIRS,  LOOP 
  
          RNC                      READ NEXT COMMAND
GEN1      SPACE  4
**        GEN1 -  GENERATE A CLASS 1 ASSEMBLER INSTRUCTION
* 
*      COMMAND: 
*         W$OPNAME/OPCODE,
*         FUNCTION1,         (V.R.N. FOR REGISTER J)
*         FUNCTION2,         (V.R.N. FOR REGISTER K)
*         FUNCTION3          (V.R.N. FOR REGISTER I)
* 
*      OTEXT= 
*         12/OPCODE,         (DOPCODE FROM COMDECK INSTDEFS)
*         16/<VRN FOR REG I> (DRI FROM COMDECK INSTDEFS)
*         16/<VRN FOR REG J> (DRI FROM COMDECK INSTDEFS)
*         16/<VRN FOR REG K> (DRI FROM COMDECK INSTDEFS)
  
  
 GEN1     SX.TMP 1                 ENSURE ROOM FOR 1 WORD 
          CHECKOT 
  
*      EXTRACT INSTRUCTION OPCODE 
  
          LX.CMD W$OPNAME          RIGHT-JUSTIFY OPNAME 
          MX.TMP -W$OPNAME
          SB.LFT B.LFT-W$OPNAME    DECREMENT NO. BITS LEFT IN X.CMD 
          BX.SAV -X.TMP*X.CMD      EXTRACT OPNAME 
  
          $BEGIN
          SA.SAV /BUG202C/VFUN+1   SAVE OPNAME FOR DEBUG
          SX.STO 1                 REMEMBER TO CLEAR
          SA.STO /BUG202C/PTR 
          $END
  
          LX.SAV 48                DOPCODE IS U(0,0,12) 
          LX.CMD 5                 RIGHT-JUSTIFY VREG FIELD 
          SB.LFT B.LFT-5           NOTE BITS SHIFTED
          MX.TMP -5 
          BX.TMP -X.TMP*X.CMD      EXTRACT VREG OFFSET
          ZR     X.TMP,GEN1.1      IF LONG FORM 
          $BEGIN
          SA.LOD /BUG202C/PTR 
          SX.STO /FIXED/VREGB0-1+X.TMP
          SA.STO /BUG202C/ARG+X.LOD+1 
          $END
          SA.TMP FIXCELLS+/FIXED/VREGB0-1+X.TMP 
          $BEGIN
          BX.STO X.TMP
          SA.STO /BUG202C/VFUN+X.LOD+1
          SX.STO X.LOD+B..1 
          SA.STO A.LOD
          $END
          EQ     GEN1.2 
  
 GEN1.1   EVALFUNC
 GEN1.2   BSS    0                 X.TMP = V.R.N. FOR REGISTER J
          LX.TMP 16                DRJ IS U(0,28,16)
          BX.SAV X.SAV+X.TMP
          LX.CMD 5                 RIGHT-JUSTIFY VREG FIELD 
          SB.LFT B.LFT-5           NOTE BITS SHIFTED
          MX.TMP -5 
          BX.TMP -X.TMP*X.CMD      EXTRACT VREG OFFSET
          ZR     X.TMP,GEN1.3 
          $BEGIN
          SA.LOD /BUG202C/PTR 
          SX.STO /FIXED/VREGB0-1+X.TMP
          SA.STO /BUG202C/ARG+X.LOD+1 
          $END
          SA.TMP FIXCELLS+/FIXED/VREGB0-1+X.TMP 
          $BEGIN
          BX.STO X.TMP
          SA.STO /BUG202C/VFUN+X.LOD+1
          SX.STO X.LOD+B..1 
          SA.STO A.LOD
          $END
          EQ     GEN1.4 
  
 GEN1.3   EVALFUNC
 GEN1.4   BSS    0                 X.TMP = V.R.N. FOR REGISTER K
          BX.SAV X.SAV+X.TMP       DRK IS U(0,44,16)
  
          CMD@60 W$C+W$OPNAME+5+FUNC+5+FUNC,(5+FUNC)
          ALIGN  5+FUNC            ENSURE X.CMD HAS VREG
  
          LX.CMD 5                 RIGHT-JUSTIFY VREGOF FIELD 
          SB.LFT B.LFT-5           NOTE BITS SHIFTED
          MX.TMP -5 
          BX.TMP -X.TMP*X.CMD      EXTRACT VREG OFFSET
          ZR     X.TMP,GEN1.6      IF LONG FORM 
          SA.GET =X_RCOUNT
 GEN1.5   SX.STO X.GET+B..1 
          SA.STO A.GET
          $BEGIN
          SA.LOD /BUG202C/PTR 
          SX.STO /FIXED/VREGB0-1+X.TMP
          SA.STO /BUG202C/ARG+X.LOD+1 
          SX.STO /FUNCTION/VREGOF 
          SA.STO /BUG202C/FUN+X.LOD+1 
          $END
          BX.STO X.GET
          $BEGIN
          SA.GET FIXCELLS+/FIXED/VREGB0-1+X.TMP 
          $END
          SA.STO FIXCELLS+/FIXED/VREGB0-1+X.TMP 
          BX.TMP X.STO
          $BEGIN
          SA.STO /BUG202C/VFUN+X.LOD+1
          SX.STO X.LOD+B..1 
          SA.STO A.LOD
          $END
          EQ     GEN1.7 
 GEN1.6   EVALFUNC
 GEN1.7   BSS    0                 X.TMP = V.R.N. FOR REGISTER I
          LX.TMP 32                DRI IS U(0,12,16)
          BX.STO X.SAV+X.TMP
          STOROTXT                 STORE X.STO IN OTEXT BUFFER
  
          RNC                      READ NEXT COMMAND
GEN2      SPACE  4
**        GEN2 -  GENERATE A CLASS 2 ASSEMBLER INSTRUCTION
* 
*      COMMAND: 
*         W$OPNAME/OPCODE,
*         FUNCTION1          (V.R.N. FOR REGISTER I)
*         FUNCTION2          (JK) 
* 
*      OTEXT= 
*         12/OPCODE,         (DOPCODE FROM COMDECK INSTDEFS)
*         16/<VRN FOR REG I> (DRI FROM COMDECK INSTDEFS)
*         14/0, 
*         18/JK              (DCONST FROM COMDECK INSTDEFS) 
  
  
 GEN2     SX.TMP 1
          CHECKOT                  ENSURE X.TMP WORDS IN OTEXT BUFFER 
  
          LX.CMD W$OPNAME          RIGHT-JUSTIFY OPNAME 
          SB.LFT B.LFT-W$OPNAME    DECREMENT NO. OF BITS LEFT IN X.CMD
          MX.TMP -W$OPNAME
          BX.SAV -X.TMP*X.CMD      EXTRACT OPNAME 
  
          $BEGIN
          SA.SAV /BUG202C/VFUN+1   SAVE OPNAME FOR DEBUG
          SX.STO 1                 REMEMBER TO CLEAR VFUN+1 
          SA.STO /BUG202C/PTR 
          $END
  
          LX.SAV 48                DOPCODE IS U(0,0,12) 
          LX.CMD 5                 RIGHT-JUSTIFY VREGOF FIELD 
          SB.LFT B.LFT-5           NOTE BITS SHIFTED
          MX.TMP -5 
          BX.TMP -X.TMP*X.CMD      EXTRACT VREG OFFSET
          ZR     X.TMP,GEN2.2      IF LONG FORM 
          SA.GET =X_RCOUNT
 GEN2.1   SX.STO X.GET+B..1 
          SA.STO A.GET
          $BEGIN
          SA.LOD /BUG202C/PTR 
          SX.STO /FIXED/VREGB0-1+X.TMP
          SA.STO /BUG202C/ARG+X.LOD+1 
          SX.STO /FUNCTION/VREGOF 
          SA.STO /BUG202C/FUN+X.LOD+1 
          $END
          BX.STO X.GET
          $BEGIN
          SA.GET FIXCELLS+/FIXED/VREGB0-1+X.TMP 
          $END
          SA.STO FIXCELLS+/FIXED/VREGB0-1+X.TMP 
          BX.TMP X.STO
          $BEGIN
          SA.STO /BUG202C/VFUN+X.LOD+1
          SX.STO X.LOD+B..1 
          SA.STO A.LOD
          $END
          EQ     GEN2.3 
  
 GEN2.2   EVALFUNC
 GEN2.3   BSS    0                 X.TMP = V.R.N. FOR REGISTER I
          LX.TMP 32                DRI IS U(0,12,16)
          BX.SAV X.SAV+X.TMP
          EVALFUNC                 SET X.TMP = VALUE FOR JK 
          CMD@60 W$C+W$OPNAME+5+FUNC+FUNC 
          MX.GET -18               ALLOW NEGATIVE JK FIELD
          BX.TMP -X.GET*X.TMP 
          BX.STO X.SAV+X.TMP       DCONST IS U(0,42,18) 
          STOROTXT                 STORE X.STO IN OTEXT BUFFER
  
          RNC                      READ NEXT COMMAND
GEN3      SPACE  4
**        GEN3 -  GENERATE A CLASS 3 ASSEMBLER INSTRUCTION
* 
*      COMMAND: 
*         W$OPNAME/OPCODE,
*         FUNCTION1,         (V.R.N. FOR REGISTER J)
*         FUNCTION2,         (V.R.N. FOR REGISTER I)
*         FUNCTION3          (SYMBOLIC ADDRESS) 
* 
*      OTEXT= 
*         12/OPCODE,         (DOPCODE FROM COMDECK INSTDEFS)
*         16/<VRN FOR REG I> (DRI FROM COMDECK INSTDEFS)
*         16/<VRN FOR REG J> (DRJ FROM COMDECK INSTDEFS)
*         16/0
* 
*         12/0, 
*         18/<SUBSCRIPT OFFSET> 
*                            (DCONS FROM COMDECK INSTDEFS)
*         4/MOD, 8/TABLE, 18/INDEX
*                            (DCONS FROM COMDECK INSTDEFS)
  
  
 GEN3     SX.TMP 2                 ENSURE ROOM FOR 2 WORDS
          CHECKOT 
  
          LX.CMD W$OPNAME          RIGHT-JUSTIFY OPNAME 
          SB.LFT B.LFT-W$OPNAME    DECREMENT NO. BITS LEFT IN X.CMD 
          MX.TMP -W$OPNAME
          BX.SAV -X.TMP*X.CMD      EXTRACT OPNAME 
  
          $BEGIN
          SA.SAV /BUG202C/VFUN+1   SAVE OPNAME FOR DEBUG
          SX.STO 1                 REMEMBER TO CLEAR VFUN+1 
          SA.STO /BUG202C/PTR 
          $END
  
          LX.SAV 48                DOPCODE IS U(0,0,12) 
          LX.CMD 5                 RIGHT-JUSTIFY VREG FIELD 
          SB.LFT B.LFT-5           NOTE BITS SHIFTED
          MX.TMP -5 
          BX.TMP -X.TMP*X.CMD      EXTRACT VREG OFFSET
          ZR     X.TMP,GEN3.1      IF LONG FORM 
          $BEGIN
          SA.LOD /BUG202C/PTR 
          SX.STO /FIXED/VREGB0-1+X.TMP
          SA.STO /BUG202C/ARG+X.LOD+1 
          $END
          SA.TMP FIXCELLS+/FIXED/VREGB0-1+X.TMP 
          $BEGIN
          BX.STO X.TMP
          SA.STO /BUG202C/VFUN+X.LOD+1
          SX.STO X.LOD+B..1 
          SA.STO A.LOD
          $END
          EQ     GEN3.2 
  
 GEN3.1   EVALFUNC
 GEN3.2   BSS    0                 X.TMP = V.R.N. FOR REGISTER J
          LX.TMP 16                DRJ IS U(0,28,16)
          BX.SAV X.SAV+X.TMP
          LX.CMD 5                 RIGHT-JUSTIFY VREG FIELD 
          SB.LFT B.LFT-5           NOTE BITS SHIFTED
          MX.TMP -5 
          BX.TMP -X.TMP*X.CMD      EXTRACT VREG OFFSET
          ZR     X.TMP,GEN3.3      IF LONG FORM 
          $BEGIN
          SA.LOD /BUG202C/PTR 
          SX.STO /FIXED/VREGB0-1+X.TMP
          SA.STO /BUG202C/ARG+X.LOD+1 
          $END
          SA.TMP FIXCELLS+/FIXED/VREGB0-1+X.TMP 
          $BEGIN
          BX.STO X.TMP
          SA.STO /BUG202C/VFUN+X.LOD+1
          SX.STO X.LOD+B..1 
          SA.STO A.LOD
          $END
          EQ     GEN3.4 
  
 GEN3.3   EVALFUNC
 GEN3.4   BSS    0                 X.TMP = V.R.N. FOR REGISTER K
          LX.TMP 32                DRI IS U(0,12,16)
          BX.STO X.SAV+X.TMP
          STOROTXT                 STORE X.STO IN OTEXT BUFFER
  
          CMD@60 W$C+W$OPNAME+FUNC+FUNC,(FUNC)
          ALIGN  FUNC 
  
  
          SX.STO 0                 ENSURE NO TABL REF IF FIXED CELL 
          SA.STO /INT/TABL
          EVALFUNC                 SET X.TMP = SUBSCRIPT OFFSET 
          MX.GET -18               ALLOW NEGATIVE SUBSCRIPT OFFSET
          BX.TMP -X.GET*X.TMP 
          SA.LOD /INT/TABL         4/MOD, 8/TABLE, 18/INDEX 
          LX.TMP 30                DCONS IS U(0,12,18)
          BX.STO X.TMP+X.LOD
          STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
          RNC                      READ NEXT COMMAND
GEN4      SPACE  4
**        GEN4 -  GENERATE A CLASS 4 ASSEMBLER INSTRUCTION
* 
*      COMMAND: 
*         W$OPNAME/OPCODE,
*         FUNCTION           (SYMBOLIC ADDRESS) 
* 
*      OTEXT= 
*         12/OPCODE,         (DOPCODE FROM COMDECK INSTDEFS)
*         18/SUBSCR. OFFSET  (DCONS FROM COMDECK INSTDEFS)
*         4/MOD, 8/TABLE, 18/INDEX
*                            (DTABL FROM COMDECK INSTDEFS)
  
  
 GEN4     SX.TMP 1                 ENSURE ROOM FOR 1 WORD 
          CHECKOT 
  
          LX.CMD W$OPNAME          RIGHT-JUSTIFY OPNAME 
          SB.LFT B.LFT-W$OPNAME 
          MX.TMP -W$OPNAME
          BX.SAV -X.TMP*X.CMD      EXTRACT OPNAME 
  
          $BEGIN
          SA.SAV /BUG202C/VFUN+1   SAVE OPNAME FOR DEBUG
          SX.STO 1                 REMEMBER TO CLEAR VFUN+1 
          SA.STO /BUG202C/PTR 
          $END
  
          LX.SAV 48                DOPCODE IS U(0,0,12) 
          SX.STO 0                 ENSURE NO TABL REF IF FIXED CELL 
          SA.STO /INT/TABL
          EVALFUNC                 SET X.TMP = SUBSCRIPT OFFSET 
          MX.GET -18               ALLOW NEGATIVE SUBSCRIPT OFFSET
          BX.TMP -X.GET*X.TMP 
          LX.TMP 30                DCONS IS U(0,12,18)
          SA.LOD /INT/TABL         4/MOD, 8/TABLE, 18/INDEX 
          BX.STO X.TMP+X.LOD
          IX.STO X.SAV+X.STO       FINAL OTEXT WORD 
          STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
          RNC                      READ NEXT COMMAND
GEN5      SPACE  4
**        GEN5 -  GENERATE A CLASS 5 ASSEMBLER INSTRUCTION
* 
*      COMMAND: 
*         W$OPNAME/OPCODE,
*         FUNCTION1,         (V.R.N. FOR X0)
*         FUNCTION2,         (V.R.N. FOR A0)
*         FUNCTION3,         (LENGTH) 
*         FUNCTION4,         (SYMBOLIC ADDRESS 1) 
*         FUNCTION5,         (BCP 1)
*         FUNCTION6,         (SYMBOLIC ADDRESS 2) 
*         FUNCTION7          (BCP 2)
* 
*      OTEXT= 
*         12/OPCODE,         (DOPCODE FROM COMDECK INSTDEFS)
*         16/<VRN FOR X0>,   (DRI FROM COMDECK INSTDEFS)
*         16/<VRN FOR A0>,   (DRJ FROM COMDECK INSTDEFS)
*         16/LENGTH          (DRK FROM COMDECK INSTDEFS)
* 
*         12/BCP1,           (DNUM FROM COMDECK INSTDEFS) 
*         18/<SUBSCRIPT OFFSET 1>,
*                            (DCONS FROM COMDECK INSTDEFS)
*         4/MOD1, 8/TABLE1, 18/INDEX1 
*                            (DTABL FROM COMDECK INSTDEFS)
* 
*         12/BCP2,           (DNUM FROM COMDECK INSTDEFS) 
*         18/<SUBSCRIPT OFFSET 2>,
*                            (DCONS FROM COMDECK INSTDEFS)
*         4/MOD2, 8/TABLE2, 18/INDEX2 
*                            (DTABL FROM COMDECK INSTDEFS)
  
  
 GEN5     SX.TMP 3                 ENSURE ROOM FOR 3 WORDS
          CHECKOT 
  
          LX.CMD W$OPNAME          RIGHT-JUSTIFY OPNAME 
          SB.LFT B.LFT-W$OPNAME    DECREMENT NO. BITS LEFT IN X.CMD 
          MX.TMP -W$OPNAME
          BX.SAV -X.TMP*X.CMD      EXTRACT OPNAME 
          SX.SAV  X.SAV+/OPNAMES/NO$
  
          $BEGIN
          SA.SAV /BUG202C/VFUN+1   SAVE OPNAME FOR DEBUG
          SX.STO 1                 REMEMBER TO CLEAR VFUN+1 
          SA.STO /BUG202C/PTR 
          $END
  
          LX.SAV 48                DOPCODE IS U(0,0,12) 
          EVALFUNC                 SET X.TMP = V.R.N. FOR X0
          LX.TMP 32                DRI IS U(0,12,16)
          BX.SAV X.SAV+X.TMP
          EVALFUNC                 SET X.TMP = V.R.N. FOR A0
          LX.TMP 16                DRJ IS U(0,28,16)
          BX.SAV X.SAV+X.TMP
          CMD@60  W$C+W$OPNAME+FUNC+FUNC,(FUNC) 
          ALIGN  3*FUNC 
          EVALFUNC                 SET X.TMP = LENGTH 
          BX.STO X.SAV+X.TMP       DRK IS U(0,44,16)
          STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
          SX.STO 0                 ENSURE NO TABL REF IF FIXED CELL 
          SA.STO /INT/TABL
          EVALFUNC                 SET X.TMP = SUBSCRIPT OFFSET 1 
          MX.GET -18               ALLOW NEGATIVE SUBSCRIPT OFFSET
          BX.TMP -X.GET*X.TMP 
          LX.TMP 30                DCONS IS U(0,12,18)
          SA.LOD /INT/TABL         4/MOD1, 8/TABLE1, 18/INDEX1
          BX.SAV X.TMP+X.LOD
          EVALFUNC                 SET X.TMP = BCP 1
          LX.TMP 48                DNUM IS U(0,0,12)
          BX.STO X.TMP+X.SAV
          STOROTXT                 STORE X.STO INTO OTEXT BUFFER
          CMD@60  FUNC+FUNC+FUNC,(FUNC) 
          ALIGN  2*FUNC 
  
          SX.STO 0                 ENSURE NO TABL REF IF FIXED CELL 
          SA.STO /INT/TABL
          EVALFUNC                 SET X.TMP = SUBSCRIPT OFFSET 2 
          MX.GET -18               ALLOW NEGATIVE SUBSCRIPT OFFSET
          BX.TMP -X.GET*X.TMP 
          LX.TMP 30                DCONS IS U(0,12,18)
          SA.LOD /INT/TABL         4/MOD2, 8/TABLE2, 18/INDEX2
          BX.SAV X.TMP+X.LOD
          EVALFUNC                 SET X.TMP = BCP 2
          LX.TMP 48                DNUM IS U(0,0,12)
          BX.STO X.TMP+X.SAV
          STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
          RNC                      READ NEXT COMMAND
GEZ       SPACE  4
**        GEZ -  SET FUNCTION3 = (FUNCTION1 .GE. FUNCTION2) 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION3          RESULT OPERAND 
* 
*      DOES-
*         IF FUNCTION1 GE FUNCTION2  THEN 
*             FUNCTION3 = 1 
*         ELSE
*             FUNCTION3 = 0.
  
  
 GEZ      EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.LOD X.SAV-X.TMP
          SX.STO B..1              ASSUME FUNCTION1 GE FUNCTION2
          PL     X.LOD,GEZ1        IF CORRECT ASSUMPTION,  SKIP 
          SX.STO B..0              NOTE NOT (FUNCTION1 GE FUNCTION2)
 GEZ1     BSS    0                 (X.STO IS SET CORRECTLY) 
          STORFUNC                 STORE X.STO ACCORIDNG TO FUNCTION
  
          RNC                      READ NEXT COMMAND
GOTOCASE  SPACE  4
**        GOTOCASE -  BRANCH ACCORDING TO CASE
* 
*      COMMAND: 
*         FUNCTION,          TARGET VALUE 
*         BSS    0           (FORCE NEW WORD) 
* 
*         12/VALUE, 18/ADDRESS
*         ... 
*         12/VALUE, 18/ADDRESS
*         12/7777B, 18/ADDRESS
* 
*      DOES-
*         IF THE TARGET VALUE IS EQUAL TO ANY OF THE SPECIFIED VALUES,
*             A BRANCH IS MADE TO THE ASSOCIATED ADDRESS
*         ELSE
*             A BRANCH IS MADE TO THE ADDRESS ASSOCIATED WITH THE 7777B.
  
  
 GOTOCASE EVALFUNC                 SET X.TMP = TARGET VALUE 
          SB.SCR X.TMP
          SB.LIM 7777B             ENDCASE VALUE
          MX.GET -12               77777777777777770000B
          SB.TMP B..60-B.LFT       BITS USED BY *GOTOCASE* + FUNCTION 
          LT     B.CNT,B.TMP,GOTOCAS1 IF ABOVE IN SAME X.WRD
          SA.WRD A.WRD-B..1        RESET A.WRD TO START AT BEG. OF LIST 
  
 GOTOCAS1 SA.WRD A.WRD+B..1        GET NEXT COMMAND WORD
          LX.WRD 12                RIGHT-JUSTIFY VALUE
          BX.TMP -X.GET*X.WRD      EXTRACT VALUE
          SB.TMP X.TMP
          EQ     B.TMP,B.SCR,GOTOCAS2  IF MATCH,  SKIP
          EQ     B.TMP,B.LIM,GOTOCAS2  IF ENDCASE,  SKIP
          LX.WRD 30                RIGHT-JUSTIFY NEXT VALUE 
          BX.TMP -X.GET*X.WRD      EXTRACT VALUE
          SB.TMP X.TMP+0
          EQ     B.TMP,B.SCR,GOTOCAS2  IF MATCH,  SKIP
          NE     B.TMP,B.LIM,GOTOCAS1  IF NOT ENDCASE,  LOOP
  
 GOTOCAS2 BSS    0                 ADDRESS IS LEFT-JUSTIFIED IN X.WRD 
          LX.WRD 18                RIGHT-JUSTIFY ADDRESS
          $BEGIN
          BX.TMP X.WRD             SAVE FOR DMP IN CASE OF MODE ERROR 
          $END
          SA.WRD X.WRD
          SB.CNT B..0 
          BX.CMD X.WRD
          SB.LFT B..60
  
          XNC                      EXECUTE NEXT COMMAND 
GTZ       SPACE  4
**        GTZ -  SET FUNCTION3 = (FUNCTION1 GT FUNCTION2) 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         FUNCTION3          RESULT OPERAND 
* 
*      DOES-
*         IF FUNCTION1 GT FUNCTION2  THEN 
*             FUNCTION3 = 1 
*         ELSE
*             FUNCTION3 = 0.
  
  
 GTZ      EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNTION2 
          IX.LOD X.TMP-X.SAV
          SX.STO B..1              ASSUME FUNCTION1 GT FUNCTION2
          NG     X.LOD,GTZ1        IF CORRECT ASSUMPTION,  SKIP 
          SX.STO B..0              NOTE NOT (FUNCTION1 GT FUNCTION2)
 GTZ1     BSS    0                 (X.STO HAS CORRECT VALUE)
          STORFUNC                 STORE X.STO ACCORDING TO FUNCTION3 
  
          RNC                      READ NEXT COMMAND
IFZEQ     SPACE  4
**        IFZEQ -  IF FUNCTION1 EQ FUNCTION2  THEN BRANCH 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         ADDRESS 
* 
*      DOES-
*         IF FUNCTION1 EQ FUNCTION2  THEN 
*             A BRANCH IS MADE TO THE SPECIFIED ADDRESS.
  
  
 IFZEQ    EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.SAV X.SAV-X.TMP       PRESERVE (FUNCTION1 - FUNCTION2) 
  
          CMD@60 W$C+FUNC+FUNC,(ADDR) 
          ALIGN  ADDR 
  
          ZR     X.SAV,BRANCH      IF FUNCTION1 EQ FUNCTION2,  BRANCH 
          SKIPADDR                 SKIP ADDRESS IN COMMAND STRING 
  
          RNC                      READ NEXT COMMAND
IFZGE     SPACE  4
**        IFZGE -  IF FUNCTION1 GE FUNCTION2  THEN BRANCH 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         ADDRESS 
* 
*      DOES-
*         IF FUNCTION1 GE FUNCTION2  THEN 
*             A BRANCH IS MADE TO THE SPECIFIED ADDRESS.
  
  
 IFZGE    EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.SAV X.SAV-X.TMP       PRESERVE (FUNCTION1 - FUNCTION2) 
  
          CMD@60 W$C+FUNC+FUNC,(ADDR) 
          ALIGN  ADDR 
  
          PL     X.SAV,BRANCH      IF FUNCTION1 GE FUNCTION2,  BRANCH 
          SKIPADDR                 SKIP ADDRESS IN COMMAND STRING 
  
          RNC                      READ NEXT COMMAND
IFZGT     SPACE  4
**        IFZGT -  IF FUNCTION1 GT FUNCTION2  THEN BRANCH 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         ADDRESS 
* 
*      DOES-
*         IF FUNCTION1 GT FUNCTION2  THEN 
*             A BRANCH IS MADE TO THE SPECIFIED ADDRESS.
  
  
 IFZGT    EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.SAV X.TMP-X.SAV       PRESERVE (FUNCTION2 - FUNCTION1) 
  
          CMD@60 W$C+FUNC+FUNC,(ADDR) 
          ALIGN  ADDR 
  
          NG     X.SAV,BRANCH      IF FUNCTION1 GT FUNCTION2,  BRANCH 
          SKIPADDR                 SKIP ADDRESS IN COMMAND STRING 
  
          RNC                      READ NEXT COMMAND
IFZLE     SPACE  4
**        IFZLE -  IF FUNCTION1 LE FUNCTION2  THEN BRANCH 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         ADDRESS 
* 
*      DOES-
*         IF FUNCTION1 LE OPERAND2  THEN
*             A BRANCH IS MADE TO THE SPECIFIED ADDRESS.
  
  
 IFZLE    EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.SAV X.TMP-X.SAV       PRESERVE (FUNCTION2 - FUNCTION1) 
  
          CMD@60 W$C+FUNC+FUNC,(ADDR) 
          ALIGN  ADDR 
  
          PL     X.SAV,BRANCH      IF FUNCTION1 LE FUNCTION2,  BRANCH 
          SKIPADDR                 SKIP ADDRESS IN COMMAND STRING 
  
          RNC                      READ NEXT COMMAND
IFZLT     SPACE  4
**        IFZLT -  IF FUNCTION1 LT FUNCTION2  THEN BRANCH 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         ADDRESS 
* 
*      DOES-
*         IF FUNCTION1 LT FUNCTION2  THEN 
*             A BRANCH IS MADE TO THE SPECIFIED ADDRESS 
  
  
 IFZLT    EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.SAV X.SAV-X.TMP       PRESERVE (FUNCTION1 - FUNCTION2) 
  
          CMD@60 W$C+FUNC+FUNC,(ADDR) 
          ALIGN  ADDR 
  
          NG     X.SAV,BRANCH      IF FUNCTION1 LT FUNCTION2
          SKIPADDR                 SKIP ADDRESS IN COMMAND STRING 
  
          RNC                      READ NEXT COMMAND
IFZNE     SPACE  4
**        IFZNE -  IF FUNCTION1 NE FUNCTION2  THEN BRANCH 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         ADDRESS 
* 
*      DOES-
*         IF FUNCTION1 NE FUNCTION2  THEN 
*             A BRANCH IS MADE TO THE SPECIFIED ADDRESS.
  
  
 IFZNE    EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.SAV X.TMP-X.SAV       PRESERVE (FUNCTION2 - FUNCTION1) 
  
          CMD@60 W$C+FUNC+FUNC,(ADDR) 
          ALIGN  ADDR 
  
          NZ     X.SAV,BRANCH      IF FUNCTION1 NE FUNCTION2,  BRANCH 
          SKIPADDR                 SKIP ADDRESS IN COMMAND STRING 
  
          RNC                      READ NEXT COMMAND
LEZ       SPACE  4
**        LEZ -  SET FUNCTION3 = (FUNCTION1 LE FUNCTION1) 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         FUNCTION3          RESULT OPERAND 
* 
*      DOES-
*         IF FUNCTION1 LE FUNCTION2  THEN 
*             SETS FUNCTION3 = 1
*         ELSE
*             SETS FUNCTION3 = 0. 
  
  
 LEZ      EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          SX.STO B..1              ASSUME FUNCTION1 LE FUNCTION2
          IX.TMP X.TMP-X.SAV
          PL     X.TMP,LEZ1        IF CORRECT ASSUMPTION,  SKIP 
          SX.STO B..0              NOTE NOT (FUNCTION1 LE FUNCTION2)
 LEZ1     BSS    0                 X.STO HAS CORRECT VALUE
          STORFUNC                 STORE X.STO ACCORDING TO FUNCTION3 
  
          RNC                      READ NEXT COMMAND
LSHIFT    SPACE  4,8
**        LSHIFT -  LEFT-SHIFT A FIXED CELL 
* 
*      COMMAND: 
*         W$FIXED/INDEX,     INDEX TO FIXED CELL
*         6/S                SHIFT COUNT
* 
*      DOES-
*         SHIFTS THE SPECIFIED FIXED CELL LEFT (CIRCULARLY)  S  BITS. 
  
  
 LSHIFT   LX.CMD W$FIXED           RIGHT-JUSTIFY INDEX OF FIXED CELL
          BX.TMP -X.FIX*X.CMD      EXTRACT INDEX
          LX.CMD 6                 RIGHT-JUSTIFY SHIFT COUNT
          SA.LOD FIXCELLS+X.TMP    LOAD FIXED CELL
          MX.GET -6 
          BX.TMP -X.GET*X.CMD      EXTRACT SHIFT COUNT
          SB.LFT B.LFT-W$FIXED-6   DECREMENT NO. BITS LEFT IN X.CMD 
          SB.TMP X.TMP
          LX.STO X.LOD,B.TMP       LEFT-SHIFT FIXED CELL
          SA.STO A.LOD             RESTORE VALUE
          RNC                      READ NEXT COMMAND
LTZ       SPACE  4
**        LTZ -  SET FUNCTION3 = (FUNCTION1 LT FUNCTION2) 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         FUNCTION3 
* 
*      DOES-
*         IF FUNCTION1 LT FUNCTION2  THEN 
*             SETS FUNCTION3 = 1
*         ELSE
*             SETS FUNCTION3 = 0. 
  
  
 LTZ      EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.TMP X.SAV-X.TMP
          SX.STO B..1              ASSUME FUNCTION1 LT FUNCTION2
          NG     X.TMP,LTZ1        IF CORRECT ASSUMPTION,  SKIP 
          SX.STO B..0              NOTE NOT (FUNCTION1 LT FUNCTION2)
 LTZ1     BSS    0                 X.STO HAS CORRECT VALUE
          STORFUNC                 STORE X.STO ACCORDING TO FUNCTION3 
  
          RNC                      READ NEXT COMMAND
MAXZ      SPACE  4
**        MAXZ/ORZ -  SET FUNCTION3 = MAXIMUM(FUNCTION1, FUNCTION2) 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         FUNCTION3          RESULT OPERAND 
* 
*      DOES-
*         IF FUNCTION1 GT FUNCTION2  THEN 
*             SETS FUNCTION3 = FUNCTION1
*         ELSE
*             SETS FUNCTION3 = FUNCTION2. 
  
  
 MAXZ     EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.LOD X.TMP-X.SAV
          BX.STO X.SAV             ASSUME FUNCTION1 GT FUNCTION2
          NG     X.LOD,MAXZ1       IF CORRECT ASSUMPTION
          BX.STO X.TMP             FUNCTION2 GT FUNCTION1 
 MAXZ1    BSS    0                 X.STO HAS MAXIMUM VALUE
          STORFUNC                 STORE X.STO ACCORDING TO FUNCTION3 
  
          RNC                      READ NEXT COMMAND
MOVEZ     SPACE  4
**        MOVEZ -  SET FUNCTION2 = FUNCTION1
* 
*      COMMAND: 
*         FUNCTION1,         SOURCE OPERAND 
*         FUNCTION2          RESULT OPERAND 
* 
*      DOES-
*         SETS FUNCTION2 = FUNCTION1. 
  
  
 MOVEZ    EVALFUNC                 SET X.TMP = FUNCTION1
          BX.STO X.TMP
          STORFUNC                 STORE X.STO ACCORDING TO FUNCTION2 
          RNC                      READ NEXT COMMAND
MULTZ     SPACE  4
**        MULTZ -  SET FUNCTION3 = FUNCTION1 * FUNCTION2
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         FUNCTION3          RESULT OPERAND 
* 
*      DOES-
*         SETS FUNCTION3 = FUNCTION1 * FUNCTION2. 
  
  
 MULTZ    EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.STO X.SAV*X.TMP       FUNCTION1 * FUNCTION2
          STORFUNC                 STORE X.STO ACCORDING TO FUNCTION3 
  
          RNC                      READ NEXT COMMAND
NEZ       SPACE  4
**        NEZ -  SET FUNCTION3 = (FUNCTION1 NE FUNCTION2) 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         FUNCTION3          RESULT OPERAND 
* 
*      DOES-
*         IF FUNCTION1 NE FUNCTION2  THEN 
*             SETS FUNCTION3 = 1
*         ELSE
*             SETS FUNCTION3 = 0. 
  
  
 NEZ      EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.TMP X.SAV-X.TMP
          SX.STO B..1              ASSUME FUNCTION1 NE FUNCTION2
          NZ     X.TMP,NEZ1        IF CORRECT ASSUMPTION,  SKIP 
          SX.STO B..0              NOTE NOT (FUNCTION1 NE FUNCTION2)
 NEZ1     BSS    0                 X.STO HAS CORRECT VALUE
          STORFUNC                 STORE X.STO ACCORDING TO FUNCTION3 
  
          RNC                      READ NEXT COMMAND
NOTE      SPACE  4
**        NOTE -  PUT NOTE ON ASSEMBLY LISTING
* 
*      COMMAND: 
*         48/NOTENAME 
* 
*      OTEXT= 
*         12/OPCODE,         (DOPCODE FROM COMDECK INSTDEFS)
*         16/0, 
*         14/1,              (DCOUNT FROM COMDECK INSTDEFS) 
*         18/N               (DCONST FROM COMDECK INSTDEFS) 
* 
*         60/NOTE CHARACTERS
* 
*      THE ABOVE TWO WORDS ARE REPEATED THREE TIMES WITH N = 2, 1, 0
*         AND SUCCESSIVE NOTE WORDS.
  
  
 NOTE     BSS    0
  
 DEBUGA   IFEQ   DEBUGA,1          IF *NOTE* CODE IS ASSEMBLED
  
          MX.TMP 48 
          BX.SAV X.TMP*X.CMD       SAVE NOTE NAME 
          LX.CMD 48                SKIP NOTE NAME 
          SB.LFT B.LFT-48          DECREMENT NO. BITS LEFT IN X.CMD 
          CMD@60 W$C+W$SUBCOM+48
  
          $BEGIN
              SX.TMP 6                 ENSURE 6 WORDS IN OTEXT BUFFER 
              CHECKOT 
  
              SA.LOD NOTEWRD1          12/NOTED, 16/0, 14/1, 18/2 
              BX.STO X.LOD
              STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
              SA.LOD NOTEWRD2          42/0, 18/3H +
              SA.GET /INT/MODADR       ADDRESS OF CURRENT MODULE COMMAND
              SA.GET X.GET             MODULE NAME
              MX.TMP 7*6               77777777777777000000B
              BX.GET X.TMP*X.GET       42/MODULE NAME, 18/0 
              IX.STO X.LOD+X.GET       (<MODUL> + ) 
DEBUGC    IFEQ   DEBUGC,1          IF DEBUG VERSION OF COMPILER 
              SA.STO /BUG202C/VFUN+1
DEBUGC    ENDIF 
              STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
              SA.LOD NOTEWRD3          12/NOTED, 16/0, 14/1, 18/1 
              BX.STO X.LOD
              STOROTXT                 STORE X.STO INTO OTXT BUFFER 
  
              SA.GET /INT/MODADR
              SX.TMP A.WRD
              IX.TMP X.TMP-X.GET       RELATIVE ADDRESS 
              MX.LOD -3                77777777777777777770B
              SX.STO B..0 
1             DUP    5
              BX.GET -X.LOD*X.TMP 
              LX.TMP -3 
              IX.STO X.STO+X.GET
              LX.STO -6 
1             ENDD
              SA.LOD NOTEWRD4          60/10H00000  = 
              IX.STO X.STO+X.LOD       60/10H77777  = 
DEBUGC    IFEQ   DEBUGC,1          IF DEBUG VERSION OF COMPILER 
              SA.STO /BUG202C/VFUN+2
DEBUGC    ENDIF 
              STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
              SA.LOD NOTEWRD5          12/NOTED, 16/0, 14/1, 18/0 
              BX.STO X.LOD
              STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
              SA.LOD NOTEWRD6          48/0, 12/2H
              BX.STO X.SAV+X.LOD       60/10HNOTENAME 
DEBUGC    IFEQ   DEBUGC,1          IF DEBUG VERSION OF COMPILER 
              SA.STO /BUG202C/VFUN+3
DEBUGC    ENDIF 
              STOROTXT                 STORE X.STO INTO OTEXT BUFFER
  
DEBUGC    IFEQ   DEBUGC,1          IF DEBUG VERSION OF COMPILER 
          SX.STO 3
          SA.STO /BUG202C/PTR      REMEMBER TO CLEAR VFUNS
DEBUGC    ENDIF 
  
  
          RNC                      READ NEXT COMMAND
 DEBUGA   ENDIF 
PUSH      SPACE  4
**        PUSH -  PUSH DOWN FIXED CELLS IN STACK
* 
*      COMMAND: 
*         W$FIXED/FIX_1, 1/1, 
*         ... 
*         W$FIXED/FIX_M, 1/1, 
*         W$FIXED/FIX_N, 1/0
  
  
          CMD@60 W$C+W$SUBCOM,(6*W$FIXED+6) 
 PUSH     RJ     ALIGN       ENSURE 60 COMMAND BITS 
          LX.CMD -1          PREPARE FOR LOOP 
  
 PUSH1        LX.CMD 1+W$FIXED         RIGHT-JUSTIFY INDEX TO FIXED CELL
              SB.LFT B.LFT-1-W$FIXED   DECREMENT NO. BITS IN X.CMD
              BX.TMP -X.FIX*X.CMD      EXTRACT INDEX
              SA.LOD /PUSHPOP/TOP 
  
              $BEGIN
              SB.TMP X.LOD-/PUSHPOP/MAX 
              GE     B.TMP,B..0,400000B+* 
              $END
  
              SX.SAV X.LOD+B..1        INCREMENT INDEX TO TOP OF STACK
              SA.SAV A.LOD
              SA.LOD FIXCELLS+X.TMP    LOAD VALUE OF FIXED CELL 
              BX.STO X.LOD
              SA.STO /PUSHPOP/STACK+X.SAV  SAVE VALUE IN STACK
  
              $BEGIN
              BX.STO X.TMP             SAVE INDEX FOR CHECK 
              SA.STO /PUSHPOP/STACKORD+X.SAV
              SA.GET /BUG202C/PTR 
              SA.STO /BUG202C/ARG+X.GET+1 
              BX.STO X.LOD             SAVE VALUE OF FIXED CELL 
              SA.STO /BUG202C/VFUN+X.GET+1
              SX.STO X.GET+B..1 
              SA.STO A.GET
              $END
  
              NG     X.CMD,PUSH1       IF MORE FIXED CELLS TO PUSH, LOOP
  
          LX.CMD 1                 SKIP FINAL FLAG BIT
  
          RNC                      READ NEXT COMMAND
POP       SPACE  4
**        POP -  POP UP FIXED CELLS FROM STACK
* 
*      COMMAND: 
*         W$FIXED/FIX_N, 1/1, 
*         W$FIXED/FIX_M, 1/1, 
*         ... 
*         W$FIXED/FIX_2, 1/1, 
*         W$FIXED/FIX_1, 1/0
  
  
          CMD@60 W$C+W$SUBCOM,(6*W$FIXED+6) 
 POP      RJ     ALIGN       ENSURE 60 COMMAND BITS 
          LX.CMD -1          PREPARE FOR LOOP 
  
 POP1         LX.CMD 1+W$FIXED         RIGHT-JUSTIFY FIXED CELL 
              SB.LFT B.LFT-1-W$FIXED   DECREMENT NO. BITS LEFT IN X.CMD 
              SA.LOD /PUSHPOP/TOP 
  
              $BEGIN
              NG     X.LOD,400000B+*
              $END
  
              BX.TMP -X.FIX*X.CMD      EXTRACT INDEX TO FIXED CELL
  
              $BEGIN
              SA.GET /PUSHPOP/STACKORD+X.LOD
              IX.GET X.GET-X.TMP
              NZ     X.GET,400000B+*
              BX.STO X.TMP             SAVE INDEX FOR DEBUG 
              SA.GET /BUG202C/PTR 
              SA.STO /BUG202C/ARG+X.GET+1 
              SX.STO X.GET+B..1 
              SA.STO A.GET
              SB.TMP X.GET
              SA.GET /PUSHPOP/STACK+X.LOD 
              BX.STO X.GET             SAVE VALUE FOR DEBUG 
              SA.STO /BUG202C/VFUN+B.TMP+1
              $END
  
              SA.GET /PUSHPOP/STACK+X.LOD 
              BX.STO X.GET
              SA.STO FIXCELLS+X.TMP    RESTORE VALUE OF FIXED CELL
              SX.STO X.LOD-1
              SA.STO A.LOD             CHANGE /PUSHPOP/TOP
              NG     X.CMD,POP1        IF MORE FIXED CELLS TO POP,  LOOP
  
          LX.CMD 1                 SKIP LAST FLAG BIT 
  
          RNC                      READ NEXT COMMAND
QUOTZ     SPACE  4
**        QUOTZ -  SET FUNCTION3 = FUNCTION1 / FUNCTION2
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         FUNCTION3 
* 
*      DOES-
*         SETS FUNCTION3 = FUNCTION1 / FUNCTION2
  
  
 QUOTZ    EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          PX.SAV X.SAV             CONVERT FUNCTION1 TO 
          NX.SAV X.SAV               FLOATING POINT FORMAT
          PX.TMP X.TMP             CONVERT FUNCTION2 TO 
          NX.TMP X.TMP               FLOATING POINT FORMAT
          FX.STO X.SAV/X.TMP       FUNCTION1 / FUNCTION2  (FLT. PT.)
          UX.STO X.STO,B.TMP
          LX.STO X.STO,B.TMP       CONVERT TO INTEGER 
          STORFUNC                 STORE X.STO ACCORDING TO FUNCTION3 
  
          RNC                      READ NEXT COMMAND
REMZ      SPACE  4
**        REMZ -  SET FUNCTION3 = REMAINDER OF FUNCTION1 / FUNCTION2
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         FUNCTION3          RESULT OPERAND 
* 
*      DOES-
*         SETS FUNCTION3 = REMAINDER OF FUNCTION1 / FUNCTION2.
* 
*      NOTE-
*         IF FUNCTION1 IS NEGATIVE,  FUNCTION3 MAY BE NEGATIVE. 
*         (I.E. *REMZ* IS NOT A MODULUS OPERATION.) 
  
  
 REMZ     EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          PX.LOD X.SAV             CONVERT FUNCTION1 TO 
          NX.LOD X.LOD               FLOATING POINT FORMAT
          PX.GET X.TMP             CONVERT FUNCTION2 TO 
          NX.GET X.GET               FLOATING POINT FORMAT
          FX.STO X.LOD/X.GET       FUNCTION1 / FUNCTION2  (FLT. PT.)
          UX.STO X.STO,B.TMP       CONVERT TO INTEGER 
          LX.STO X.STO,B.TMP
          IX.STO X.STO*X.TMP       (FUNCTION1 / FUNCTION2) * FUNCTION2
          IX.STO X.SAV-X.STO       REMAINDER
          STORFUNC                 STORE X.STO ACCORDING TO FUNCTION3 
  
          RNC                      READ NEXT COMMAND
RETURNZ   SPACE  4
**        RETURNZ -  RETURN FROM INTERPRETIVE CALL
* 
*      COMMAND: 
*         (NO PARAMETERS) 
* 
*      DOES-
*         POPS THE CALL/RETURN STACK
*         AND RESUMES INTERPRETATION ACCORDING TO THE ENTRY.
  
  
 RETURNZ  SA.GET /STACK/PTR 
          SX.SAV X.GET-1
          SA.LOD /STACK/WORD0+X.SAV+1  B.LFT, MODADR, B.CNT, A.WRD
          SA.SAV A.GET             STORE NEW /STACK/PTR 
          UX.LOD B.LFT,X.LOD       RESTORE B.LFT
  
          $BEGIN
          SX.STO X.GET             SAVE LEVEL FOR DEBUG TRACE 
          SA.STO /BUG202C/SPTR
          $END
  
          SA.WRD X.LOD             RESTORE A.WRD
          LX.LOD 30                12/2000B+B.CNT,12/A.WRD,12/,18/MODADR
          UX.LOD B.CNT,X.LOD       RESTORE B.CNT
          SX.STO X.LOD
          SA.STO /INT/MODADR       RESTORE INT$MODADR 
  
          SA.LOD /STACK/WORD1+X.SAV+1  CORRECTLY SHIFTED X.CMD
          SA.GET /STACK/WORD2+X.SAV+1  CORRECTLY SHIFTED X.WRD
          BX.CMD X.LOD
          LX.WRD X.GET
  
          $BEGIN
          SA.LOD /STACK/WORD3+X.SAV+1  42/EGONAME, 18/EGOADDRESS
          SA.GET =3R
          MX.TMP 42 
          BX.STO X.TMP*X.LOD
          IX.STO X.STO+X.GET
          SA.STO /BUG202C/EGNM     RESTORE BUG202C$EGNM 
          SX.STO X.LOD
          SA.STO /BUG202C/EGAD     RESTORE BUG202C$EGAD 
          $END
  
          RNC                      READ NEXT COMMAND
STOPZ     SPACE  4
**        STOPZ -  STOP INTERPRETATION
* 
*      COMMAND: 
*         (NO PARAMETERS) 
* 
*      DOES-
*         SETS INT$STOPPED = TRUE.
*         EXITS FROM *CGENINT* (REGARDLESS OF DEBUG/NON-DEBUG VERSION). 
  
  
 STOPZ    SX.STO 1                 TRUE  (SYMPL)
          SA.STO /INT/STOPPED 
          EQ     CGENINT           EXIT FROM *CGENINT*
SUBCOM    SPACE  4
**        SUBCOM -  PROCESS A SUBCOMMAND
* 
*      COMMAND: 
*         W$SUBCOM/SUBOPCODE
*         ... 
* 
*      DOES-
*         EXECUTES THE COMMAND AS IF IT WERE A NORMAL COMMAND.
  
  
 SUBCOM   LX.CMD W$SUBCOM          RIGHT-JUSTIFY SUB-COMMAND INDEX
          SB.LFT B.LFT-W$SUBCOM    DECREMENT NO. OF BITS LEFT IN X.CMD
          MX.TMP -W$SUBCOM
          BX.STO -X.TMP*X.CMD      EXTRACT SUB-COMMAND
          SB.TMP X.STO
  
          $BEGIN
          SA.STO /BUG202C/SOP      SAVE FOR DEBUG 
          $END
  
          JP     SUBCOML+B.TMP     GO EXECUTE COMMAND 
SUBZ      SPACE  4
**        SUBZ -  SET FUNCTION3 = FUNCTION1 - FUNCTION2 
* 
*      COMMAND: 
*         FUNCTION1,         FIRST OPERAND
*         FUNCTION2,         SECOND OPERAND 
*         FUNCTION3          RESULT OPERAND 
* 
*      DOES-
*         SETS FUNCTION3 = FUNCTION1 - FUNCTION2
  
  
 SUBZ     EVALFUNC                 SET X.TMP = FUNCTION1
          BX.SAV X.TMP             PRESERVE IT
          EVALFUNC                 SET X.TMP = FUNCTION2
          IX.STO X.SAV-X.TMP       FUNCTION1 - FUNCTION2
          STORFUNC                 STORE X.STO ACCORDING TO FUNCTION3 
  
          RNC                      READ NEXT COMMAND
          TITLE  SUPPORT ROUTINES 
ALIGN     EJECT 
**        ALIGN -  ALIGN THE NEXT 60 COMMAND BITS INTO X.CMD
* 
*         X.CMD CONTAINS B.LFT UNUSED COMMAND BITS, 
*           LEFT-JUSTIFIED. 
*         X.WRD CONTAINS THE B.CNT UNUSED COMMAND BITS (LEFT-JUSTIFIED) 
*           CONTINUOUSLY FOLLOWING THE UNUSED COMMAND BITS IN X.CMD.
*         A.WRD CONTAINS THE ADDRESS FOR X.WRD. 
*           (I.E. (A.WRD+B..1) CONTAINS THE 60 UNUSED COMMAND BITS
*           CONTIGUOUSLY FOLLOWING THE UNUSED COMMAND BITS IN X.WRD.
* 
*         RJ     ALIGN
* 
* 
*         SETS X.CMD TO THE NEXT 60 UNUSED COMMAND BITS.
*         SETS B.LFT = 60.
*         ADJUSTS A.WRD, X.WRD, AND B.CNT AS NEEDED.
  
  
  
*      SHORT CASE:  60 UNUSED BITS ARE IN X.CMD AND X.WRD 
  
 ALIGN1   SB.CNT B.TMP-60          UNUSED BITS IN X.WRD 
          SB.TMP B..60-B.LFT       BITS TO BE TAKEN FROM X.WRD
          LX.WRD X.WRD,B.TMP       LEFT-JUSTIFY UNUSED BITS 
          BX.GET -X.GET*X.WRD 
          SB.LFT 60 
          BX.CMD X.CMD+X.GET       COMPLETE RESULT
  
 ALIGN    BSS    1                 ENTRY/EXIT WORD
          SA.GET MASKTBL+B.LFT     <B.LFT>/-0, <REST>/0 
          SB.TMP B.LFT+B.CNT       NO. BITS IN X.CMD + X.WRD
          BX.CMD X.GET*X.CMD       ISOLATE UNUSED BITS
          GE     B.TMP,B..60,ALIGN1 IF SHORT CASE 
          ZR     B.CNT,ALIGN2      IF NO BITS IN X.WRD
  
*      BITS NEEDED FROM X.CMD, X.WRD AND (A.WRD+B..1) 
  
          SA.GET MASKTBL+B.TMP     <B.CNT+B.LFT>/-0, <REST>/0 
          SA.LOD MASKTBL+B.CNT     <B.CNT>/-0, <REST>/0 
          SB.TMP B..60-B.LFT       TO PROPERLY SHIFT X.WRD
          BX.TMP X.LOD*X.WRD       KEEP ONLY UNUSED BITS
          SA.WRD A.WRD+B..1        GET NEXT COMMAND WORD
          LX.TMP X.TMP,B.TMP       PROPERLY POSITION MIDDLE PART
          SB.CNT B.CNT+B.LFT       NO. BITS CURRENTLY IN X.CMD AFTER NXT
                                   ALSO, UNUSED BITS TO BE LEFT IN X.WRD
          BX.CMD X.CMD+X.TMP       COMBINE FIRST AND SECOND PARTS 
          SB.TMP B..60-B.CNT       TO RIGHT-JUSTIFY NEEDED BITS IN X.WRD
          LX.WRD X.WRD,B.TMP
          BX.GET -X.GET*X.WRD      EXTRACT THIRD PART 
          SB.LFT B..60             NO. BITS SET UP IN X.CMD 
          BX.CMD X.CMD+X.GET       COMPLETE RESULT
          EQ     ALIGN             EXIT 
  
  
*      NO BITS ARE IN X.WRD 
  
 ALIGN2   SA.WRD A.WRD+B..1        GET NEXT 60 UNUSED COMMAND BITS
          SB.TMP B..60-B.LFT       NO. BITS NEEDED FROM X.WRD 
          SB.CNT B.LFT             NO. BITS TO BE LEFT IN X.WRD 
          LX.WRD X.WRD,B.TMP       PROPERLY POSITION X.WRD
          BX.GET -X.GET*X.WRD      EXTRACT NECESSARY UNUSED BITS
          SB.LFT B..60             NO. UNUSED COMMAND BITS IN X.WRD 
          BX.CMD X.CMD+X.GET       COMPLETE RESULT
          EQ     ALIGN             EXIT 
DEBUGRNC  EJECT 
**        DEBUGRNC -  READ/EXECUTE NEXT COMMAND FOR DEBUG 
* 
*      CALLING FORM:  
*         EQ     DEBUGRNC 
* 
*      DOES:  
*         CONVERTS A.WRD, B.CNT AND B.LFT TO /INT/ADDR AND /INT/POS.
*         EXITS FROM *CGENINT*. 
  
  
          $BEGIN
 DEBUGRNC SX.STO A.WRD             PROSPECTIVE /INT/ADDR
          SB.TMP B..60-B.CNT       LAST SYMPL BIT IN (A.WRD)
          SX.SAV B.TMP-B.LFT       BEGINNING SYMPL BIT POSITION IN A.WRD
          PL     X.SAV,DEBUGRN1    IF LEGAL BIT NUMBER
          SX.STO X.STO-1           BACK UP TO PREVIOUS WORD 
          SX.SAV X.SAV+60          MAKE BIT NUMBER LEGAL
 DEBUGRN1 SA.STO /INT/ADDR
          SA.SAV /INT/POS 
          EQ     CGENINT
          $END
GETFUNC   EJECT 
PUTFUNC   EJECT 
**        PUTFUNC -  GRACEFULLY CALL *STOFUNC*
* 
*         CALLED BY STORFUNC MACRO. 
* 
*         STORES X.STO ACCORDING TO THE FUNCTION. 
*         PRESERVES X.SAV AND BACKGROUND REGISTERS. 
  
  
COMPRESS  IF     -DEF,/COMPRESS/STORFUNC
  
 PUTFUNC  BSS    1                 ENTRY/EXIT WORD
          SA.STO /INT/VFUN         STORE FOR *STOFUNC*
          LX.CMD 1+W$FUNC          RIGHT-JUSTIFY FUNCTION NUMBER
  
1         IFEQ   W$FUNC,W$FIXED 
          BX.STO -X.FIX*X.CMD      EXTRACT FUNCTION NUMBER
1         ELSE
          MX.STO -W$FUNC
          BX.STO -X.STO*X.CMD      EXTRACT FUNCTION NUMBER
1         ENDIF 
  
          SA.STO /INT/FUN          STORE FOR *STOFUNC*
          LX.CMD W$FIXED           RIGHT-JUSTIFY PARAMETER
          SB.LFT B.LFT-1-W$FUNC-W$FIXED 
          BX.STO -X.FIX*X.CMD      EXTRACT PARAMETER
          SA.STO /INT/ARG          STORE FOR *STOFUNC*
          SA.LOD FIXCELLS+X.STO    LOAD FIXED CELL
          BX.STO X.LOD               (JUST IN CASE) 
          SA.STO /INT/VARG         STORE FOR *STOFUNC*  (MAYBE) 
  
          SAVE                     SAVE RELEVANT REGISTERS
          RJ     =X_STOFUNC        STORE VFUN 
  
1         $BEGIN
          SA.TMP /BUG202C/PTR      INDEX TO SAVED FUNCTIONS 
          SX.STO X.TMP+1           INCREMENT INDEX
          SA.STO A.TMP
          SA.LOD /INT/ARG          STACK INT$ARG
          SA.GET /INT/FUN          STACK INT$FUN
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/ARG+X.TMP+1 
          SA.SAV /BUG202C/FUN+X.TMP+1 
          SA.LOD /INT/VARG         STACK INT$VARG 
          SA.GET /INT/VFUN         STACK INT$VFUN 
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/VARG+X.TMP+1
          SA.SAV /BUG202C/VFUN+X.TMP+1
          SA.LOD /INT/VFIX         STACK INT$VFIX 
          SA.GET /INT/TABL         STACK INT$TABL 
          BX.STO X.LOD
          LX.SAV X.GET
          SA.STO /BUG202C/VFIX+X.TMP+1
          SA.SAV /BUG202C/TABL+X.TMP+1
1         $END
  
          RESTORE                  RESTORE RELEVANT REGISTERS 
  
          EQ     PUTFUNC           EXIT 
  
COMPRESS  ENDIF 
WRITEFUN  EJECT 
**        WRITEFUN -  WRITE EVALUATED FUNCTIONS ON OTEXT
* 
*         X.LOD = NUMBER OF FUNCTIONS TO BE WRITTEN 
*         RJ     WRITEFUN 
* 
* 
*         WRITES OTEXT IN THE FORM: 
*         18/FUNCTION1, 
*         18/FUNCTION2, 
*         18/FUNCTION3, 
*         6/0 
* 
*         ETC.
  
  
 WRITEFUN BSS    1                 ENTRY/EXIT WORD
          ZR     X.LOD,WRITEFUN    IF NO FUNCTIONS, EXIT
          BX.SAV X.LOD             SAVE NUMBER OF FUNCTIONS 
  
 WRITEFU1     ALIGN  FUNC 
              EVALFUNC                 SET X.TMP = FUNCTION 
              LX.TMP 42                INTO U(0,0,18) 
              BX.STO X.TMP
              SX.SAV X.SAV-1           DECREMENT NUMBER OF FUNCTIONS
              ZR     X.SAV,WRITEFU2    IF JUST DID LAST FUNCTION
  
              SA.STO TEMP              PRESERVE CURRENT OTEXT WORD
              ALIGN  FUNC 
              EVALFUNC                 SET X.TMP = FUNCTION 
              LX.TMP 24                INTO U(0,18,18)
              SA.LOD TEMP              RELOAD CURRENT OTEXT WORD
              BX.STO X.LOD+X.TMP       BUILD CURRENT OTEXT WORD 
              SX.SAV X.SAV-1           DECREMENT NUMBER OF FUNCTIONS
              ZR     X.SAV,WRITEFU2    IF JUST DID LAST FUNCTION,  SKIP 
  
              SA.STO A.LOD             PRESERVE CURRENT OTEXT WORD
              ALIGN  FUNC 
              EVALFUNC                 SET X.TMP = FUNCTION 
              LX.TMP 6                 INTO U(0,36,18)
              SA.LOD TEMP              RELOAD CURRENT OTEXT WORD
              BX.STO X.LOD+X.TMP       BUILD CURRENT OTEXT WORD 
              SX.SAV X.SAV-1           DECREMENT NUMBER OF FUNCTIONS
  
 WRITEFU2     STOROTXT                 STORE X.STO INTO OTEXT BUFFER
              NZ     X.SAV,WRITEFU1    IF MORE FUNCTIONS,  LOOP 
  
          EQ     WRITEFUN          EXIT 
          SPACE  4
          END 
