*DECK GMCS
          IDENT  GMCS 
          SST 
          MACHINE ANY,I 
          COMMENT MCS VERBS PROCESSOR 
 GMCS     MODULE
 CGACCME  KNIL   CGACCME
 CGDISAB  KNIL   CGDISAB
 CGENABL  KNIL   CGENABL
 CGII     KNIL   CGII 
 CGPURGE  KNIL   CGPURGE
 CGRECEI  KNIL   CGRECEI
 CGSEND   KNIL   CGSEND 
 SUBLOAD  LINK   SUBLOAD
 SETBXPK  LINK   CGSBXPK
 MOVER    LINK   GMOVER 
 ADNAT    LINK   ADNAT
 SUBDNAT  LINK   SUBDNAT
 SUBREF   LINK   SUBREF 
 SENDCD   EQU    REGB 
 SENDFROM EQU    REGC 
 SENDWITH EQU    REGD 
 SENDBA   EQU    REGE 
 SENDADV  EQU    REGF 
 SENDA0   EQU    VREG1
 SENDX0   EQU    VREG2
 SENDX1   EQU    VREG3
 SENDX4   EQU    VREG4
 SENDB4   EQU    VREG5
 SENDB5   EQU    VREG6
 SENDB6   EQU    VREG7
 SENDB7   EQU    VREG8
 FWACD    EQU    VREG1
 AMC      EQU    VREG2
 INITIAL  EQU    VREG2
 NODAT    EQU    VREG2
 MAXCD    EQU    VREG2
 THEVERB  EQU    VREG3
 MSGORSEG EQU    VREG3
 PASSWORD EQU    VREG4
 FWAINTO  EQU    VREG4
 TERMINAL EQU    VREG5
 BCPINTO  EQU    VREG5
 LGTHINTO EQU    VREG6
 PWLENGTH EQU    VREG6
NODBREG   EQU    VREG7
 VERBATOM EQU    REGA 
 CDNAME   EQU    REGB 
 MSGSEG   EQU    REGC 
 PWATOM   EQU    REGC 
 IOATOM   EQU    REGD 
 RCVINTO  EQU    REGD 
 TERMATOM EQU    REGE 
 NSLABEL  EQU    REGE 
 ISLABEL  EQU    REGF 
          EJECT 
 CGSEND   EGO    1
          NOTE   CGSEND 
 SENDL1   LABEL 
  
          IFZ    ((GCODEOF,SENDWITH),NE,GSUBVERB),SENDL2
  
*                            SEND WITH ESI
*                            SX0   34B
  
          IFTHEN ((GSCODEOF,SENDWITH),EQ,GESI)
            GEN  SXBPK,(VREGOF,SENDX0),,34B 
          ENDIFZ
  
*                            SEND WITH EMI
*                            SX0   35B
  
          IFTHEN ((GSCODEOF,SENDWITH),EQ,GEMI)
            GEN  SXBPK,(VREGOF,SENDX0),,35B 
          ENDIFZ
  
*                            SEND WITH EGI
*                            SX0   36B
  
          IFTHEN ((GSCODEOF,SENDWITH),EQ,GEGI)
            GEN  SXBPK,(VREGOF,SENDX0),,36B 
          ENDIFZ
  
*                            SEND WITH PHRASE OMITTED 
*                            SX0   33B
  
          IFTHEN ((GSCODEOF,SENDWITH),EQ,GNULL) 
            GEN  SXBPK,(VREGOF,SENDX0),,33B 
          ENDIFZ
          BRANCH SENDL3 
  
 SENDL2   LABEL 
  
*                            SEND WITH IDENTIFIER-2 
*                            WE WANT THE VALUE OF IDENTIFIER-2 IN X0
*                            CREATE A REGISTER TEMP DNAT
*                            CALL MOVER TO GENERATE THE CODE TO MOVE
*                            THE VALUE OF IDENTIFIER TO THE REGISTER
*                            RELEASE THE REGISTER TEMP DNAT 
*                            OK TO CLOBBER REGB, REGC 
  
          PUSH   REGB,REGC
          MOVEZ  SENDWITH,REGB                   SOURCE FOR MOVER 
          MOVEZ  REGT12,REGT                     REG ENTRY FOR ADNAT
          CALLZ  ADNAT
          MOVEZ  COMP,(TYPEOF,REGT) 
          MOVEZ  1,(NUMLENOF,REGT)
          MOVEZ  REGT,REGC                       DESTINATION FOR MOVER
          CALLZ  MOVER                           GENERATE THE MOVE
          MOVEZ  (TREGOF,REGC),SENDX0            VREG ASSIGNED BY ADNAT 
          CALLZ  SUBDNAT                         RELEASE THE DNAT 
          POP    REGB,REGC
  
 SENDL3   LABEL 
  
*                            SEND BEFORE/AFTER ADVANCING
  
*                            BEFORE/AFTER OPTION IS OMITTED 
*                            MX1   0
*                            MX4   0
  
          IFTHEN ((GSCODEOF,SENDBA),EQ,GNULL) 
            GEN  MASK,(VREGOF,SENDX1),0 
            GEN  MASK,(VREGOF,SENDX4),0 
            BRANCH SENDL7 
          ENDIFZ
  
*                            SEND BEFORE/AFTER ADVANCING PAGE 
*                            SX1   34B
*                            SX4   2     BEFORE 
*                            SX4   3     AFTER
  
          IFZ    ((GSCODEOF,SENDADV),NE,GPAGE),SENDL4 
          GEN    SXBPK,(VREGOF,SENDX1),,34B 
          IFTHEN ((GSCODEOF,SENDBA),EQ,GBEFORE) 
            GEN  SXBPK,(VREGOF,SENDX4),,2 
          ELSEZ 
            GEN  SXBPK,(VREGOF,SENDX4),,3 
          ENDIFZ
          BRANCH SENDL7 
  
 SENDL4   LABEL 
  
*                            SEND BEFORE/AFTER ADVANCING MNEMONIC NAME
*                            SX1   MNEMONIC NAME CHARACTER
*                            SX4   0     BEFORE 
*                            SX4   1     AFTER
  
          IFZ    ((GCODEOF,SENDADV),NE,GSYSREF),SENDL6
          GEN    SXBPK,(VREGOF,SENDX1),,(MNVALOF,SENDADV) 
          IFTHEN ((GSCODEOF,SENDBA),EQ,GBEFORE) 
            GEN  MASK,(VREGOF,SENDX4),0 
          ELSEZ 
            GEN  SXBPK,(VREGOF,SENDX4),,1 
          ENDIFZ
          BRANCH SENDL7 
  
 SENDL6   LABEL 
  
*                            SEND BEFORE/AFTER ADVANCING INTEGER LINES
*                            SEND BEFORE/AFTER ADV IDENTIFIER-3 LINES 
*                            SX1   INTEGER VALUE NUMBER OF LINES
*                            SX4   4     BEFORE 
*                            SX4   5     AFTER
  
*                            WE WANT THE VALUE OF INTEGER/IDENT IN X1 
*                            ADNAT CREATES A REGISTER TEMP DNAT VIA REGT12
*                            VIRTUAL REG NUMBER IS IN (TREGOF,RETT) 
*                            VREG NUMBER IS IN (TREGOF,REGT)
*                            GMOVER GENERATES CODE TO LOAD X-REGISTER 
*                            FOR EITHER LITERAL OR IDENTIFIER 
  
          PUSH   REGB,REGC
          MOVEZ  SENDADV,REGB                    SOURCE FOR GMOVER
          MOVEZ  REGT12,REGT                     INPUT TO ADNAT 
          CALLZ  ADNAT
          MOVEZ  COMP1,(TYPEOF,REGT)
          MINZ   (NUMLENOF,SENDADV),8,(NUMLENOF,REGT) 
          MOVEZ  REGT,REGC                       DESTINATION FOR GMOVER 
          PUSH   SENDX0 
          CALLZ  MOVER
          POP    SENDX0 
          MOVEZ  (TREGOF,REGC),SENDX1 
          CALLZ  SUBDNAT                         GIVE BACK DNAT 
          IFTHEN ((GSCODEOF,SENDBA),EQ,GBEFORE) 
            GEN  SXBPK,(VREGOF,SENDX4),,4 
          ELSEZ 
            GEN  SXBPK,(VREGOF,SENDX4),,5 
          ENDIFZ
          POP    REGB,REGC
  
 SENDL7   LABEL 
  
*                            CD-NAME PROCESSING 
*                            SA0   FWA CD AREA
*                            SB4   MAX LENGTH OF CD IN CHARACTERS 
  
          GEN    SABPK,(VREGOF,SENDA0),,((FWA$OF,SENDCD)) 
          GEN    SBBPK,(VREGOF,SENDB4),,(BYTLENOF,SENDCD) 
  
*                            SEND FROM IDENTIFIER 
*                            FROM IDENTIFIER HAS BEEN OMITTED 
*                            SB5  B0
*                            SB6  B0
*                            SB7  B0
  
          IFTHEN ((GCODEOF,SENDFROM),EQ,GSUBVERB) 
            GEN  SBBPB,(VREGOF,SENDB5)
            GEN  SBBPB,(VREGOF,SENDB6)
            GEN  SBBPB,(VREGOF,SENDB7)
            BRANCH SENDL8 
          ENDIFZ
  
*                            SEND FROM IDENTIFIER IS PRESENT
*                            SB5   FWA FROM IDENTIFIER
*                            SB6   BCP FROM IDENTIFIER
*                            SB7   LENGTH FROM IDENTIFIER 
  
          GEN    SBBPK,(VREGOF,SENDB5),,((FWA$OF,SENDFROM)) 
  
          IFTHEN ((GSCODEOF,SENDFROM),NE,0) 
            MOVEZ  SENDFROM,P2
            CALLZ  SUBREF 
            GEN    SBXPB,(VREGOF,SENDB6),P3 
            GEN    SBXPB,(VREGOF,SENDB7),P4 
  
          ELSEZ 
  
*                            THE IDENTIFIER IS NOT SUBSCRIPTED
  
            GEN   SBBPK,(VREGOF,SENDB6),,(BCPOF,SENDFROM) 
            GEN    SBBPK,(VREGOF,SENDB7),,(BYTLENOF,SENDFROM) 
  
          ENDIFZ
  
  
 SENDL8   LABEL 
          GENOBJ N=C.SEND,I=(SENDA0,SENDX0,SENDX1,SENDX4,SENDB4,SENDB5,S
,ENDB6,SENDB7)
          RETURN
          EJECT 
 CGPURGE  EGO    1
          NOTE   CGPURGE
          GEN    SABPK,(VREGOF,FWACD),,((FWA$OF,CDNAME))
          GEN    SBBPK,(VREGOF,MAXCD),,(BYTLENOF,CDNAME)
          GENOBJ N=C.PURGE,I=(FWACD,MAXCD)
          RETURN
          EJECT 
 CGACCME  EGO    1
          NOTE   CGACCME
          GEN    SABPK,(VREGOF,FWACD),,((FWA$OF,CDNAME))
          GEN    SXBPK,(VREGOF,AMC),,2
          GENOBJ N=C.MCS12,I=(FWACD,AMC)
          RETURN
          EJECT 
 CGII     EGO    1
          NOTE   CGII 
          GEN    SABPK,(VREGOF,FWACD),,((FWA$OF,CDNAME))
          GEN    SXBPB,(VREGOF,INITIAL),,VREGB1 
          GENOBJ N=C.MCS12,I=(FWACD,INITIAL)
          RETURN
          EJECT 
 CGRECEI  EGO    1
          NOTE   CGRECEI
  
*                            CD-NAME PROCESSING 
*                            SA0 FWA CD AREA
  
          GEN    SABPK,(VREGOF,FWACD),,((FWA$OF,CDNAME))
          PUSH   FWACD
  
*                            NO DATA PROCESSING 
*                            SB3 B0  NO DATA OMITTED
*                            SB3 B1  NO DATA PRESENT
  
          IFTHEN ((GCODEOF,NSLABEL),EQ,GSUBVERB)
            GEN  SBBPB,(VREGOF,NODAT) 
          ELSEZ 
            GEN  SBBPB,(VREGOF,NODAT),,VREGB1 
          ENDIFZ
          PUSH   NODAT
  
*                            MESSAGE OR SEGMENT PROCESSING
*                            SB4 B0  RECEIVE MESSAGE
*                            SB4 B1  RECEIVE SEGMENT
  
          IFTHEN ((GSCODEOF,MSGSEG),EQ,GMESSAGE)
            GEN  SBBPB,(VREGOF,MSGORSEG)
          ELSEZ 
            GEN  SBBPB,(VREGOF,MSGORSEG),,VREGB1
          ENDIFZ
          PUSH   MSGORSEG 
  
*                            RECEIVE INTO IDENTIFIER
*                            SB5 FWA INTO IDENTIFIER
*                            SB6 BCP INTO IDENTIFIER
*                            SB7 LENGTH INTO IDENTIFIER 
  
          GEN    SBBPK,(VREGOF,FWAINTO),,((FWA$OF,RCVINTO)) 
          PUSH   FWAINTO
          IFTHEN ((GSCODEOF,RCVINTO),NE,0)
            MOVEZ  RCVINTO,P2 
            CALLZ  SUBREF 
            GEN    SBXPB,(VREGOF,BCPINTO),P3
            GEN    SBXPB,(VREGOF,LGTHINTO),P4 
          ELSEZ 
  
*                            THE INTO IDENTIFIER IS NOT SUBSCRIPTED 
  
            GEN  SBBPK,(VREGOF,BCPINTO),,(BCPOF,RCVINTO)
            GEN  SBBPK,(VREGOF,LGTHINTO),,(BYTLENOF,RCVINTO)
          ENDIFZ
          POP    FWAINTO
          POP    MSGORSEG 
          POP    NODAT
          POP    FWACD
          GENOBJ N=C.RECVE,I=(FWACD,NODAT,MSGORSEG,FWAINTO,BCPINTO,LGTHI
,NTO),O=((VREGOF,NODBREG))
          IFZ    ((GCODEOF,NSLABEL),EQ,GSUBVERB),RECL1
  
*                NO DATA IS PRESENT 
          IFTHEN ((GCODEOF,ISLABEL),EQ,GSUBVERB)
            GEN  EQ$,NODBREG,,((FWA$OF,NSLABEL))
          ELSEZ 
            GEN  NE$,NODBREG,,((FWA$OF,ISLABEL))
          ENDIFZ
 RECL1    LABEL 
          RETURN
          EJECT 
 CGDISAB  EGO    1
          NOTE   CGDISAB
 CGENABL  EGO    1
          NOTE   CGENABL
          GEN    SABPK,(VREGOF,FWACD),,((FWA$OF,CDNAME))
          PUSH   FWACD
          IFTHEN ((GSCODEOF,VERBATOM),EQ,GDISABLE)
            GEN  SXBPB,(VREGOF,THEVERB) 
          ELSEZ 
            GEN  SXBPB,(VREGOF,THEVERB),,VREGB1  ENABLE 
          ENDIFZ
          PUSH   THEVERB
          PUSH   CDNAME 
          MOVEZ  PWATOM,REGB                     SOURCE FOR MOVER 
          MOVEZ  REGT12,REGT                     REG ENTRY FOR ADNAT
          CALLZ  ADNAT
          MOVEZ  ALPHNUM,(TYPEOF,REGT)
          MINZ   (BYTLENOF,PWATOM),10,P3
          MOVEZ  P3,(BYTLENOF,REGT) 
          MOVEZ  REGT,REGC                       DESTINATION FOR MOVER
          GEN    SBBPK,(VREGOF,PWLENGTH),,P3
          PUSH   PWLENGTH 
          CALLZ  MOVER
          MOVEZ  (TREGOF,REGC),PASSWORD 
          CALLZ  SUBDNAT
          POP    PWLENGTH 
          POP    CDNAME 
          POP    THEVERB
          POP    FWACD
          IFZ    ((GSCODEOF,IOATOM),EQ,GOUTPUT),LOUT
*                            INPUT
          IFTHEN ((GSCODEOF,TERMATOM),EQ,GTERMIN) 
            GEN  SBBPB,(VREGOF,TERMINAL),,VREGB1 TERMINAL 
          ELSEZ 
            GEN  SBBPB,(VREGOF,TERMINAL)         NOT TERMINAL 
          ENDIFZ
          GENOBJ N=C.EDIN,I=(FWACD,THEVERB,TERMINAL,PASSWORD,PWLENGTH)
          RETURN
 LOUT     LABEL 
          GEN    SBBPK,(VREGOF,MAXCD),,(BYTLENOF,CDNAME)
          GENOBJ N=C.EDOUT,I=(FWACD,THEVERB,MAXCD,PASSWORD,PWLENGTH)
          RETURN
          END 
