*COMDECK COMDTOK
 COMDTOK  CTEXT  COMDTOK 2.0 - *TEST* MODE DEBUG UTILITY FOR *COMCTOK*. 
 TOK      SPACE  4
          IF     -DEF,QUAL$,1 
          QUAL   COMDTOK
          BASE   D
 TOK      SPACE  4,10 
***       COMDTOK - *TEST* MODE DEBUG UTILITY FOR *COMCTOK*.
*         P CLARE   77/02/26
*         P CLARE   78/04/27 VERSION 2.0
 TOK      SPACE  4,10 
***       COMDTOK - *TEST* MODE DEBUG UTILITY FOR *COMCTOK*.
* 
* 
*         THIS DECK CONTAINS A FEW *TEST* MODE DEBUGGING UTILITY
*         SUBROUTINES THAT CAN BE USEFUL IN HELPING ONE DEBUG THEIR 
*         *TOGEL* PROGRAMS. 
* 
*         *COMDTOK* CAN BE USED TO DEASSEMBLE *TOGEL* BINARY
*         INSTRUCTIONS (ASSEMBLED VIA *COMATOK*), AND TO PROVIDE
*         THE ABILITY TO PLACE *COMCTOK* IN STEP MODE.  THAT IS,
*         TO ALLOW THE PROGRAMMER TO CONTROL THE EXECUTION/INTERPRETING 
*         OF *TOGEL* BINARY INSTRUCTIONS BY *COMCTOK*, AND TO ALLOW 
*         THE PROGRAMMER TO OBSERVE THE GENERATION OF TOKENS
*         BY *COMCTOK* ON AN INSTRUCTION BY INSTRUCTION BASIS.
* 
*         IN THE FOLLOWING PARAGRAPHS, *ASSEMBLY-TIME DEPENDENCIES* 
*         REFERS TO INTERFACES THAT THE *COMDTOK* INSTALLER MUST
*         PROVIDE.  *ASSEMBLY-TIME OPTIONS* REFERS TO INTERFACES
*         THAT ARE OPTIONAL, I.E. THAT HAVE A DEFAULT VALUE.
* 
************************************************************************
* 
*         ASSEMBLY-TIME DEPENDENCIES -- 
* 
************************************************************************
* 
*         *COMCTOK* (TOKEN GENERATOR) MUST BE ASSEMBLED WITH THE
*         SYMBOL *TEST* SET TO .NZ.  THIS WILL FORCE ASSEMBLY OF
*         CODE IN *COMCTOK* TO INTERFACE WITH *COMDTOK*.
* 
************************************************************************
* 
*         *COMSTOK*, WHICH CONTAINS THE SYMBOLS THAT DESCRIBE/DEFINE
*         THE *TOGEL* BINARY INSTRUCTION FORMATS, MUST BE PROVIDED. 
* 
************************************************************************
* 
*         *COMDTOK* INTERFACES WITH *COMCIDP* (FORMERLY *DBG=IDP*), 
*         THE INTERACTIVE DEBUG PACKAGE, AND THEREFORE REQUIRES 
*         *COMSIDP*, WHICH CONTAINS *IDP* INTERFACE MACRO AND SYMBOL
*         DEFINITIONS.
* 
************************************************************************
* 
*         SUMMARY OF REQUIRED COMDECKS -- 
* 
*         COMCIDP   COMCMCS   COMCTOK 
* 
*         COMSIDP   COMSTOK 
* 
*         NOTE-- *COMCIDP* AND *COMCTOK* HAVE THEIR OWN SET OF REQUIRED 
*         COMDECKS.  THIS LIST ASSUMES THAT THE PROGRAMMER HAS ALREADY
*         CONFIGURED AND INSTALLED *COMCIDP* AND *COMCTOK*. 
* 
************************************************************************
 TOGELI   SPACE  4,10 
**        TOGELI - DEFINE *TOGEL* INSTRUCTION/OPCODE. 
* 
* 
*         THIS MACRO DEFINES A TABLE ENTRY THAT CAN BE USED 
*         BY EITHER *TID* OR *TOD* IN PROCESSING A BINARY *TOGEL* 
*         INSTRUCTION.  SEE *TID/TOD*.
* 
* TOFU    TOGELI DPC
* 
* COF     TOGELI CASEOF 
* 
*         ENTRY  TOFU = TOFU SUFFIX FOR THIS *TOGEL* INSTRUCTION, 
*                       I.E. PROCESSOR ADDRESSES ARE FORMED BY SUFFIXING
*                       *TOFU* TO *TOK=*, *TOD=*, AND *TID=*. 
*                DPC  = DISPLAY CODE OPCODE FOR THIS *TOGEL* BINARY 
*                       INSTRUCTION.
* 
*         EXIT   NONE 
* 
*         USES   NONE 
* 
*         CALLS  NONE 
  
  
          PURGMAC TOGELI
  
          MACRO  TOGELI,TOFU,DPC
* 
 +        VFD    6/0,18/TID=TOFU,18/TOD=TOFU,18/=XTOK=TOFU
* 
 +        DATA   L/DPC/ 
* 
 TOGELI   ENDM
 FW.OPC   SPACE  4,10 
**        FW.OPC - *TOGEL* INSTRUCTION OPCODE TABLE.
  
  
 FW.OPC   BSS    0           ** FWA OF OPCODE TABLE **
 CAL      TOGELI CALT 
 COF      TOGELI CASEOF 
 ELS      TOGELI ELST 
 ENT      TOGELI ENDT 
 GN       TOGELI GROUP
 GO       TOGELI GOTO 
 GS       TOGELI GROUP
 IFT      TOGELI IFT
 ON       TOGELI ON 
 XEQ      TOGELI XEQ
  
 L.OPC    =      *-FW.OPC 
 PTR.     SPACE  4,10 
**        PTR. - DEFINE *PTR* (POINTER) NRS FOR *COMDTOK*.
  
  
 PTR.TOG  =      4
 PTR.TOK  =      5
 TOG=     SPACE  4,10 
**        TOG= - SAVED FWA AND LWA FOR *TOGEL*. 
  
  
 TOG=FWA  BSSZ   2
 TOG=LWA  =      TOG=FWA+1
 UKT=TOK  SPACE  4,10 
**        UKT=TOK - USER IDP KEYWORD TABLE FOR *COMDTOK*. 
  
  
 UKT=TOK  BSS    0           ** FWA OF KEYWORD TABLE ** 
 BRT      KEYW   (BRTOK TOGEL)
 TOG      KEYW   (TOGEL FWA,LWA,LEN)
 TOK      KEYW   (TOKEN FWA,LWA,LEN)
 UBT      KEYW   (UBTOK)
          DATA   0           ** END OF TABLE ** 
 UKT=LNK  DATA   0           ** LINK WORD **
 ST=BRT   SPACE  4,10 
**        HERE TO PROCESS *BRTOK TOGEL*.
  
 ST=BRT   BSS    0           ** ENTRY **
          NZ     X5,BRT1     IF KEYWORD NOT IMMEDIATELY FOLLOWED BY EOS 
          SX6    -1 
          SA6    =XTF=IDP    SET TO *BREAK ON ANY TOGEL INSTRUCTION*
          EQ     IDP=MN 
  
*         SEARCH FOR *TOGEL* DPC OPCODE.
  
 BRT1     SB7    L.OPC       (B7) = LEN OF *TOGEL* OPCODE TABLE 
          MX1    TB.TOCL
          SA5    A5+B1       (X5) = TOKEN CONTAINING *TOGEL* OPC
*                                   TO BREAK AT 
          SX6    X5-O.VAR 
          NZ     X6,IDP=ER   IF NOT *VAR* TOKEN, ERROR... 
          BX6    X1*X5       (X6) = TOGEL INSTRUCTION MNEMONIC, -L- FMT 
          SA1    FW.OPC+1    (A1,X1) = A+C OF 1ST DPC MNEM IN OPC TBL 
  
 BRT2     LE     B7,B0,IDP=ER  IF EOT AND NO FIND, ERROR... 
          SB2    A1          (B2) = ADDR+1 OF FOUND ENTRY, IF FOUND 
          BX7    X1-X6
          SA1    A1+2 
          SB7    B7-2 
          NZ     X7,BRT2     IF NO FIND 
  
*         HERE WITH A FIND.  SET UP (TF=IDP). 
  
          SA2    B2-B1       (X2) = OPC TBL ENTRY CONTAINING TOFU ADDR
          SX6    X2          (X6) = TOFU ADDR 
          SA6    TF=IDP 
          EQ     IDP=MN 
 ST=TOG   SPACE  4,10 
**        HERE TO PROCESS *TOGEL FWA,LWA,LEN*.
  
 ST=TOG   BSS    0           ** ENTRY **
          RJ     UTG         USER *TOGEL* OWNCODE 
          RJ     =XPAT       PARSE *FWA,LWA,LEN* TRIPLE 
          MI     B2,IDP=ER   IF FWA, LWA, OR LEN IS BAD 
          BX6    X2 
          LX7    X3 
          SA6    TOG=FWA
          SA7    TOG=LWA
  
 ST=TOG2  SA1    TOG=FWA
          SA2    A1+B1
          IX3    X2-X1
          SX6    X1+B1
          MI     X3,IDP=MN   IF FINISHED
          SA6    A1 
          RJ     TOD         TOGEL DEASSEMBLER
          MI     B2,*+4S15   IF SOME ADDR WAS BAD 
          EQ     ST=TOG2
 ST=TOK   SPACE  4,10 
**        HERE TO PROCESS *TOKEN FWA,LWA,LEN*.
  
 ST=TOK   BSS    0           ** ENTRY **
          RJ     UTK         USER *TOKEN* OWNCODE 
          RJ     PAT         PARSE *FWA,LWA,LEN* TRIPLE 
          MI     B2,IDP=ER   IF FWA, LWA, OR LEN IS BAD 
          RJ     LTK         LIST TOKENS
          EQ     IDP=MN 
 ST=UBT   SPACE  4,10 
**        HERE TO PROCESS *UBTOK*.
  
 ST=UBT   BSS    0           ** ENTRY **
          SX6    0
          SA6    TF=IDP      SET TO *NO BRTOK SELECTED* 
          EQ     IDP=MN 
 CTD      SPACE  4,10 
**        CTD - CONVERT TOKEN TYPE TO DPC.
* 
* 
*         THIS ROUTINE CONVERTS A BINARY TOKEN TYPE VALUE TO DPC
*         BY 1 OF 2 METHODS --
* 
*           1. IF THE USER PROVIDED *CTD=*, THEN CALL *CTD=*
*              TO PERFORM THE CONVERSION, ELSE
* 
*           2. IF THE USER DID NOT PROVIDE *CTD=*, THEN CALL *COD*
*              TO CONVERT THE TOKEN TYPE TO OCTAL DPC.
* 
*         ENTRY  (X1) = TOKEN TYPE, IN BINARY.
* 
*         EXIT   (X6) = TOKEN TYPE, IN -L- FMT. 
*                (X1) = (X6)
*                (B2) = .PL. IF USER PROVIDED *CTD=*, ELSE .MI. 
* 
*         USES   ALL BUT A0,X0,A5,X5,B7 
* 
*         CALLS  COD,CTD(IF AVAILABLE)
  
  
 CTD      SUBR               ** ENTRY/EXIT ** 
          SX6    B7 
          SB2    =YCTD= 
          SA6    CTDA        SAVE (B7)
          MI     B2,CTD2     IF USER DID NOT PROVIDE *CTD=* 
          RJ     =YCTD=      CONVERT TOKEN TYPE TO DPC
          EQ     CTD3 
  
 CTD2     RJ     COD         CONVERT BINARY TO OCTAL DPC
          MX2    1
          SB2    B2-B1       (B2) = NR OF BITS CONVERTED - 1
          AX2    B2          (X2) = MASK FOR EXTRACTING CONVERTED TOT 
          BX6    X2*X4       (X6) = TOKEN TYPE, IN -L- FMT
  
 CTD3     SA2    CTDA 
          SB2    =YCTD= 
          BX1    X6 
          SB7    X2          RESTORE (B7) 
          EQ     EXIT.
  
  
 CTDA     BSSZ   1           SAVED (B7) 
 DCR      SPACE  4,10 
**        DCR - DEASSEMBLE CHARACTER SHIFT MASK.
* 
* 
*         THIS ROUTINE DEASSEMBLES A CHARACTER RANGE SHIFT MASK 
*         AS WOULD OCCUR IN A *GROUP* OR *IFT* TOGEL BINARY 
*         INSTRUCTION, AND FORMATS IT FOR PRINTING. 
* 
*         ENTRY  (X4) = CHAR RANGE SHIFT MASK 
*                (B7) = ADDR OF CURRENT WORD IN PRINT LINE IMAGE
* 
*         EXIT   (B7) = ADDR OF CURRENT WORD IN PRINT LINE IMAGE, 
*                       UPDATED IF APPROPRIATE. 
* 
*         USES   X - ALL BUT X0,X5
*                A - 2,3,6,7
*                B - 1,2,4,5,7
* 
*         CALLS  MCS
  
  
 DCR      SUBR               ** ENTRY/EXIT ** 
  
*         PUT OUT LEFT PARENTHESIS DELIMITER. 
  
          SX1    1R(
          LX1    10*CHAR-1*CHAR 
          RJ     =XMCS       MERGE CODED STRING 
  
*         FIGURE OUT WHETHER TO USE A SPECIAL SYNTAX. 
*         SPECIAL SYNTAXS ARE --
*           (..)   IF ALL BITS ON, (X4) = -0
*           (-..)  IF ALL BITS OFF, (X4) = +0 
*           (-XXX) WHERE *XXX* IS THE LOGICAL COMPLEMENT OF (X4), 
*                  IF MORE BITS ARE ON THAN OFF.
  
          CX2    X4          (X2) = NR OF *ON* BITS IN (X4) 
          SX3    X2-30
          MI     X3,DCR2     IF NOT USING *-* SYNTAX
          SX1    1R-
          BX4    -X4
          LX1    10*CHAR-1*CHAR 
          RJ     =XMCS       MERGE CODED STRINGS
  
 DCR2     NZ     X4,DCR2A    IF NOT USING *..* SYNTAX 
          SX1    2R.. 
          LX1    10*CHAR-2*CHAR 
          RJ     =XMCS       MERGE CODED STRINGS
          EQ     DCR4 
  
*         INITIALIZE FOR MAIN LOOP.  SET UP (X4) SO THAT WE BEGIN 
*         AT 1ST CHAR POSITION IN DISPLAY CODE, NOT ROTATED CHAR
*         SET REPRESENTATION. 
  
 DCR2A    SB4    00B         (B4) = CURRENT CHAR IN DPC -R- FMT 
          SB5    60D         (B5) = NR OF BITS IN A WORD
          LX4    -BICH
          PL     X4,DCR3     IF : NOT SELECTED
          SX1    2R 
          LX1    10*CHAR-2*CHAR 
          RJ     =XMCS       MERGE CODED STRINGS
  
*         ** MAIN LOOP NODE **
  
 DCR3     LX4    1
          SB4    B4+B1
          GE     B4,B5,DCR4  IF DONE
          PL     X4,DCR3     IF BIT IS *OFF*
  
*         HERE IF BITS IS *ON*, OUTPUT CHARACTER. 
  
          SX1    B4 
          LX1    10*CHAR-1*CHAR 
          RJ     =XMCS       MERGE CODED STRINGS
          EQ     DCR3 
  
*         HERE WHEN DONE.  PUT OUT TERMINATING DELIMITING RIGHT PAREN.
  
 DCR4     SX1    1R)
          LX1    10*CHAR-1*CHAR 
          RJ     =XMCS       MERGE CODED STRINGS
          EQ     EXIT.
 LTK      SPACE  4,10 
**        LTK - LIST TOKENS.
* 
* 
*         THIS ROUTINE LISTS TOKENS IN THE FOLLOWING FORMAT --
* 
*     COL 1         1         1         1         1         1         1 
*         .NNNNNN.+.CCCCCCCCCCCCCCCCCCCC.....DDDDDDDDDD.....TTTTTTTTTT
* 
*         WHERE  . = BLANK(55B) 
*                N = ADDR OF TOKEN  (EITHER RELATIVE OR ABSOLUTE) 
*                + = + IF *NNNNNN* IS DECK RELATIVE, ELSE 
*                  = BLANK(55B) IF *NNNNNN* IS ABSOLUTE.
*                C = CONVERTED TOKEN (20 OCTAL DIGITS). 
*                D = UNCONVERTED TOKEN (ALL 00B CHARS CONVERTED 
*                    TO BLANKS) 
*                T = *TMAP* CHARS FOR THIS TOKEN IF *FW.TMAP* DEFINED,
*                    ELSE NULL. 
* 
*         ENTRY  (X2) = 18/0,21/LEV OF IND ADDR,21/FWA
*                (X3) = 18/0,21/LEV OF IND ADDR,21/LWA
*                (X4) = 18/0,21/LEV OF IND ADDR,21/LEN
* 
*                (X3) IS OPTIONAL PARAMETER.  IF *LEN* IS .NZ., THEN
*                TOKEN DEASSEMBLY IS FROM FWA TO FWA+LEN-1.  ELSE 
*                DEASSEMBLY IS FROM FWA TO LWA. 
* 
*         EXIT   (B2) = .MI. IF FWA, LWA, OR LEN IS BAD, ELSE .PL.
* 
*         USES   ALL
* 
*         CALLS  CAD,FLL,MCS,PRIDP,WOD,ZTB
  
  
 LTK      SUBR               ** ENTRY/EXIT ** 
          RJ     FLL         CHECK *FWA,LWA,LEN*
          MI     B2,EXIT.    IF FWA, LWA, OR LEN IS BAD 
          BX6    X2 
          LX7    X3 
          SA6    LTK=FWA     SAVE FWA 
          SA7    A6+1        SAVE LWA 
  
*         ** MAIN LOOP NODE **
  
 LTK2     SA1    LTK=FWA     (X1) = ADDR OF NEXT WORD TO DUMP 
          SA2    A1+B1       (X2) = LWA TO DUMP 
          IX3    X2-X1
          SX6    X1+B1
          SB2    B0          SET TO *NO ERROR OCCURRED* 
          MI     X3,EXIT.    IF FINISHED
          SA6    A1 
  
          RJ     CAD         CONVERT ADDR TO DPC
          SA6    SNAPLNE
          SA1    LTK=FWA
          SA1    X1-1 
          RJ     =XWOD       CONVERT FULL WORD TO OCTAL DPC 
          SA6    A6+B1
          SA7    A6+B1
          SA1    LTK=FWA
          SA1    X1-1 
          RJ     =XZTB       CONVERT ZEROES TO BLANKS 
          SA2    =5L
          MX3    5*CHAR 
          BX7    X6 
          LX6    -5*CHAR     (X6) = FGHIJABCDE
          BX7    -X3*X7      (X7) = 00000FGHIJ
          BX6    -X3*X6      (X6) = 00000ABCDE
          IX7    X7+X2       (X7) = .....FGHIJ
          BX6    X6+X2       (X6) = .....ABCDE
          LX7    5*CHAR      (X7) = FGHIJ.....
          SA6    A7+B1
          SA7    A6+B1
          SB7    A7 
  
          RJ     CTD         CONVERT TOKEN TYPE TO DPC
          MI     B2,LTK3     IF USER DID NOT PROVIDE *CTD=* 
          RJ     =XMCS       MERGE CODED STRINGS
  
 LTK3     BX6    X6-X6
          SA6    B7+B1       MARK EOL 
          PRIDP  =XSNAPLNE
          EQ     LTK2 
  
  
 LTK=FWA  =      TOG=FWA
 TID      SPACE  4,10 
**        TID - *TOK* INTERACTIVE DEBUG INTERFACE.
* 
* 
*         I ORIGINALLY INTENDED THAT THIS ROUTINE WOULD BE MORE 
*         SOPHISTICATED THAN IT CURRENTLY IS...   MY INTENTION
*         WAS/IS -- 
* 
*           1. TO HAVE *TID* DISPLAY THE CURRENT *TOGEL* INSTRUCTION
*              BEING EXECUTED.
* 
*           2. TO DISPLAY THE SOURCE LINE BEING ENTOKENED, INDICATING 
*              SOMEHOW WHERE WE CURRENTLY ARE IN THAT SOURCE LINE.
* 
*           3. TO DISPLAY THE TOKEN(S) GENERATED VIA THIS TOGEL 
*              INSTRUCTION. 
* 
*         HOWEVER, DUE TO TIME RESTRICTIONS RELATED (OF COURSE) TO
*         A LACK OF MANAGEMENT SUPPORT FOR TOOLS, WHAT YOU SEE IS 
*         WHAT YOU GET. 
* 
*         ENTRY  ENTOKENING REGISTERS INTACT
* 
*         EXIT   ENTOKENING REGISTERS STILL INTACT
* 
*         USES   X - 1,7
*                A - 1
*                B - NONE 
* 
*         CALLS  BREAK(IDP) 
  
  
 TID      SUBR               ** ENTRY/EXIT ** 
  
*         CHECK FOR A SPECIFICALLY SPECIFIED TOGEL INSTRUCTION. 
  
          SA1    =XTF=IDP    (X1) = SPECIFIED *TOGEL* INSTRUCTION 
          ZR     X1,EXIT.    IF NO BREAK
          MI     X1,TID2     IF UNCONDITIONAL BREAK 
          BX7    X2 
          LX7    0-TG.TOFUP 
          SX7    X7          (X7) = TOFU ADDR 
          IX7    X1-X7
          NZ     X7,EXIT.    IF NO MATCH, NO BREAK... 
  
 TID2     BSS    0
 BRTOK    BREAK 
          EQ     EXIT.
 TID      SPACE  4,10 
 TID=CAL  =      *+4S15 
 TID=COF  =      *+4S15 
 TID=ELS  =      *+4S15 
 TID=ENT  =      *+4S15 
 TID=GN   =      *+4S15 
 TID=GO   =      *+4S15 
 TID=GS   =      *+4S15 
 TID=IFT  =      *+4S15 
 TID=ON   =      *+4S15 
 TID=XEQ  =      *+4S15 
 TOD      SPACE  4,10 
**        TOD - *TOGEL* DEASSEMBLER.
* 
* 
*         THIS ROUTINE DEASSEMBLES A SINGLE *TOGEL* BINARY INSTRUCTION
*         AND PRINTS IT VIA *PRIDP*  (*COMCIDP* INTERFACE). 
* 
*         ENTRY  (X1) = ADDR OF *TOGEL* INSTRUCTION TO DEASSEMBLE 
* 
*         EXIT   NONE 
* 
*         USES   ALL BUT A0,X0
* 
*         CALLS  IN *COMDTOK* -- DCR
*                IN *COMCIDP* -- CAD,CHK,PRIDP
*                OTHERS       -- MCS,WOD,ZTB
  
  
 TOD      SUBR               ** ENTRY/EXIT ** 
  
*         SET UP ADDR OF *TOGEL* BINARY INSTRUCTION TO DEASSEMBLE.
  
          SX5    X1          SAVE (X1) = ADDR OF *TOGEL* INST 
          RJ     CAD         CONVERT ADDRESS
          SA6    =XSNAPLNE
  
*         CONVERT BINARY *TOGEL* INSTRUCTION TO OCTAL DPC.
  
          SA1    X5          (A1,X1) = A+C OF *TOGEL* INST TO DEASSEMBLE
          RJ     =XWOD       CONVERT A FULL BINARY WORD TO OCTAL DPC
          SA6    A6+B1
          SA7    A6+B1
  
          SA2    =10H 
          BX6    X2 
          SA6    A7+B1
  
*         SEARCH FOR *TOGEL* BINARY OPCODE (I.E. *COMCTOK/TOFU* ADDR) 
*         IN OPCODE TABLE.
  
          SA5    A1          (A5,X5) = A+C OF *TOGEL* INST TO DEASSEMBLE
          LX5    0-TG.TOFUP 
          SB7    L.OPC       (B7) = LEN OF *TOGEL* OPCODE TABLE 
          SA1    FW.OPC      (A1,X1) = A+C OF 1ST ENTRY IN OPCODE TABLE 
          SX6    X5          (X6) = ADDR TO SEARCH FOR
  
 TOD2     LE     B7,B0,TOD=DAT IF END-OF-TABLE AND NO FIND, DATA... 
          BX2    X1 
          SX1    X1 
          BX7    X6-X1
          SA1    A1+2 
          SB7    B7-2 
          NZ     X7,TOD2     IF NO FIND, CONTINUE...
  
*         HERE IF A FIND. 
* 
*           1. EXTRACT APPROPRIATE *TOD=* DEASSEMBLER ADDR
*              FOR THIS INSTRUCTION.
* 
*           2. EXTRACT APPROPRIATE OPCODE FOR THIS INSTRUCTION. 
  
          LX2    -18
          SB5    X2          (B5) = *TOD=* ADDR FOR THIS INSTRUCTION
          SA1    A1-B1       (X1) = OPCODE FOR THIS INST, -L- FMT 
          BX6    X1 
          SA6    A6+B1
          SB7    A6 
          SX1    1R 
          RJ     =XMCS       MERGE CODED STRINGS
          JP     B5+
 TOD=CAL  SPACE  4,10 
**        HERE IF *CALT XX*.
  
 TOD=CAL  BSS    0
          LX5    0-TG.CADP+TG.TOFUP-0 
          SX1    X5          (X1) = ADDR OF *CALT* PROCESSOR
          RJ     =XCAD       CONVERT ADDRESS
          SB7    A6          RESTORE (B7) 
          BX1    X6 
          RJ     =XMCS       MERGE CODED STRINGS
          EQ     TOD=X
 TOD=COF  SPACE  4,10 
**        HERE IF *CASEOF (A..Z)*.
  
 TOD=COF  BSS    0
          SX1    1R(
          RJ     =XMCS       MERGE CODED STRINGS
          LX5    0-TG.COAP+TG.TOFUP-0 
          MX2    -TG.COAL 
          BX1    -X2*X5      (X1) = 1ST CHAR IN *CASEOF* RANGE, 
*                                   DPC IN -R- FMT
          RJ     =XMCS       MERGE CODED STRINGS
          SX1    2R.. 
          RJ     =XMCS       MERGE CODED STRINGS
          LX5    0-TG.COZP+TG.COAP-0
          MX2    -TG.COZL 
          BX3    -X2*X5      (X3) = LAST CHAR IN *CASEOF* RANGE,
*                                   IN *RCS* REPRESENTATION, -R- FMT
          SX4    X1+10000B+BICH 
          BX1    -X2*X4      (X1) = LAST CHAR IN *CASEOF* RANGE,
*                                   IN DPC, -R- FMT 
          RJ     =XMCS       MERGE CODED STRINGS
          SX1    1R)
          RJ     =XMCS       MERGE CODED STRINGS
          EQ     TOD=X
 TOD=DAT  SPACE  4,10 
**        HERE IF *DATA*. 
  
 TOD=DAT  BSS    0
          SA1    =0LDATA
          BX6    X1 
          SA6    A6+B1
          SB7    A6 
          EQ     TOD=X
 TOD=ELS  SPACE  4,10 
**        HERE IF --
* 
*           1. ELST 
*           2. ENDT 
  
 TOD=ELS  BSS    0
 TOD=ENT  BSS    0
          LX5    TG.TOFUP-0 
          MX1    7*CHAR 
          BX1    X1*X5       (X1) = LABEL FOR THIS CONDITIONAL OPCODE 
          RJ     =XZTB       CONVERT ZEROES TO BLANKS 
          LX6    -CHAR
          SA6    A6-B1
          EQ     TOD=X
 TOD=GN   SPACE  4,10 
**        HERE IF *GROUP (..),TOT,NSQZ*.
  
 TOD=GN   BSS    0
          LX5    0-TG.MXAP+TG.TOFUP-0 
          SA4    X5          (X4) = CHAR SHIFT MASK 
          RJ     DCR         DASSEMBLE CHAR RANGE SHIFT MASK
          SX1    1R,
          LX1    10*CHAR-1*CHAR 
          RJ     =XMCS       MERGE CODED STRINGS
          LX5    0-TG.TOTP+TG.MXAP-0
  
          SX1    X5          (X1) = TOKEN TYPE
          RJ     CTD         CONVERT TOKEN TYPE TO DPC
          RJ     =XMCS       MERGE CODED STRINGS
  
          SA1    =L.,NSQZ.
          RJ     =XMCS       MERGE CODED STRINGS
          EQ     TOD=X
 TOD=GO   SPACE  4,10 
**        HERE IF *GOTO XX*.
  
 TOD=GO   BSS    0
          LX5    0-TG.GOTP+TG.TOFUP-0 
          SX1    X5          (X1) = ADDR TO *GOTO* TO 
          RJ     =XCAD       CONVERT ADDRESS
          SB7    A6          RESTORE (B7) 
          BX1    X6 
          RJ     =XMCS       MERGE CODED STRINGS
          EQ     TOD=X
 TOD=GS   SPACE  4,10 
**        HERE IF *GROUP (..),TOT,SQZ*. 
  
 TOD=GS   BSS    0
          LX5    0-TG.MXAP+TG.TOFUP-0 
          SA4    X5          (X4) = CHAR SHIFT MASK 
          RJ     DCR         DASSEMBLE CHAR RANGE SHIFT MASK
          SX1    1R,
          LX1    10*CHAR-1*CHAR 
          RJ     =XMCS       MERGE CODED STRINGS
          LX5    0-TG.TOTP+TG.MXAP-0
  
          SX1    X5          (X1) = TOKEN TYPE
          RJ     CTD         CONVERT TOKEN TYPE TO DPC
          RJ     =XMCS       MERGE CODED STRINGS
  
          SA1    =L.,SQZ. 
          RJ     =XMCS       MERGE CODED STRINGS
          EQ     TOD=X
 TOD=IFT  SPACE  4,10 
**        HERE IF *IFT (..)*. 
  
 TOD=IFT  BSS    0
          LX5    0-TG.MXAP+TG.TOFUP-0 
          SA4    X5          (X4) = CHAR SHIFT MASK 
          RJ     DCR         DEASSEMBLE CHAR RANGE SHIFT MASK 
          EQ     TOD=X
 TOD=ON   SPACE  4,10 
**        HERE IF *ON I,V*. 
  
  
 TOD=ON   BSS    0
          LX5    0-TG.INCP+TG.TOFUP-0 
          SX1    X5          (X1) = ADDR OF INTERUPT CELL 
          RJ     =XCAD       CONVERT ADDRESS
          SB7    A6          RESTORE (B7) 
          LX6    10*CHAR-6*CHAR 
          MX2    6*CHAR 
          BX1    X2*X6       (X1) = ADDR OF INTERUPT CELL, -L- FMT
          RJ     =XMCS       MERGE CODED STRINGS
          SX1    1R,
          RJ     =XMCS       MERGE CODED STRINGS
          SA2    B7 
          LX5    0-TG.INVP+TG.INCP-0
          BX6    X2 
          SX1    X5          (X1) = VALUE FOR INTERUPT CELL 
          SA6    B7          SAVE (B7) IN (A6)
          RJ     =XCAD       CONVERT ADDRESS (I.E. **PROBABLY** AN ADDR)
          SB7    A6          RESTORE (B7) 
          LX6    10*CHAR-6*CHAR 
          MX2    6*CHAR 
          BX1    X2*X6       (X1) = INTERUPT VALUE, -L- FORMAT
          RJ     =XMCS       MERGE CODED STRINGS
          EQ     TOD=X
  
 TOD=XEQ  SPACE  4,10 
**        HERE IF *XEQ P*.
  
  
 TOD=XEQ  BSS    0
          EQ     TOD=X       (FOR NOW, DO NOTHING...) 
 TOD=X    SPACE  4,10 
**        HERE WHEN FINISHED DEASSEMBLING *TOGEL* INSTRUCTION,
*         TIME TO PRINT LINE VIA *COMCIDP*. 
  
 TOD=X    BSS    0
          BX6    X6-X6
          SA6    B7+B1       MARK EOL 
          PRIDP  =XSNAPLNE
          SB2    B0          SET TO *NO ERROR*
          EQ     EXIT.
 UTG      SPACE  4,10 
**        UTG - USER *TOGEL* OWNCODE. 
* 
* 
*         ENTRY  NONE 
* 
*         EXIT   NONE 
* 
*         USES   CANNOT USE A5,X5,A0,X0 
* 
*         CALLS  UTG=(IF AVAIL) 
  
  
 UTG      SUBR               ** ENTRY/EXIT ** 
          SB2    =YUTG= 
          MI     B2,EXIT.    IF USER DID NOT PROVIDE *UTG=* 
          RJ     =YUTG=      USER *TOGEL* OWNCODE 
          EQ     EXIT.
 UTK      SPACE  4,10 
**        UTK - USER *TOKEN* OWNCODE. 
* 
* 
*         ENTRY  NONE 
* 
*         EXIT   NONE 
* 
*         USES   CANNOT USE A5,X5,A0,X0 
* 
*         CALLS  UTK=(IF AVAIL) 
  
  
 UTK      SUBR               ** ENTRY/EXIT ** 
          SB2    =YUTK= 
          MI     B2,EXIT.    IF USER DID NOT PROVIDE *UTK=* 
          RJ     =YUTK=      USER *TOKEN* OWNCODE 
          EQ     EXIT.
 TOK      SPACE  4,10 
 TOK=IDP  =      TID
  
  
 QUAL$    IF     -DEF,QUAL$ 
          QUAL   *
 LTK      =      /COMDTOK/LTK 
 TOK=IDP  =      /COMDTOK/TOK=IDP 
 TOK      =      /COMDTOK/TOD 
 ST=TOG   =      /COMDTOK/ST=TOG
 ST=TOK   =      /COMDTOK/ST=TOK
 QUAL$    ENDIF 
 COMDTOK  ENDX
