*DECK GCONDIT 
          IDENT  GCONDIT
 GCONDIT  TITLE  GCONDIT - CONDITIONAL STATEMENT MAIN CODE GENERATOR
  
          MACHINE  ANY,I
          SST 
          COMMENT  CONDITIONAL STATEMENT PROCESSOR
          SPACE  4
**        GCONDIT -  CONDITIONAL STATEMENT PROCESSOR
* 
*         CONTAINS: 
* 
*                RELGEN    - [NOT] EQUAL
*                            [NOT] GREATER
*                            [NOT] LESS 
*                CLASSGEN  - [NOT] ALPHABETIC 
*                            [NOT] NUMERIC
*                SIGNGEN   - [NOT] POSITIVE 
*                            [NOT] NEGATIVE 
*                SWITCHGEN - [NOT] SWITCH-NAME
  
  
  
  
  
  
 CONTROL  OPSYN  NIL
  
  
  
  
  
*CALL CCT 
  
          SPACE  4
 GCONDIT  MODULE
          TITLE  DEFINITIONS AND LINKAGES 
  
* 
*         REGISTERS FOR "A .COND. B": 
* 
 CONREGA  EQU    REGA              VERB 
 CONREGB  EQU    REGB              OPERAND A
 CONREGC  EQU    REGC              OPERAND B
 CONREGD  EQU    REGD              BRANCH FIELD 
 CONREGE  EQU    REGE              COMPARE BRANCH FLD 2 (LT BRANCH) 
* 
*         REGISTERS USED FOR PARAMETER STORAGE: 
* 
 CONREGI  EQU    REGI 
 CONREGK  EQU    REGK 
 CONREGL  EQU    REGL 
 CONREGM  EQU    REGM              USED BY GETSZVG
 CONREGT  EQU    REGT 
 CREG11   EQU    REG11
 CREG12   EQU    REG12
  
* 
*         VIRTUAL REGISTERS 
* 
 CVREGA   EQU    VREG1             VIRTUAL REGISTERS
 CVREGB   EQU    VREG2
 CVREGC   EQU    VREG3
 CVREGD   EQU    VREG4
 CVREGE   EQU    VREG5
 CVREGF   EQU    VREG6
 CVREGG   EQU    VREG7
 CVREGH   EQU    VREG8
  
*      TEMP REGISTERS USED BY SIGNGEN 
  
 LSC      EQU    T3                LEFT SHIFT COUNT 
 NOC      EQU    T4                NR OTHER CHARS IN WORD 
 LLW      EQU    T5                LENGTH LAST WORD (CHARS) 
 RCI      EQU    T5                REMAINING CHARS IN ITEM
 MXLNTH   EQU    T3                MAX ITEM LNTH - CHARS
 MNLNTH   EQU    T4                MIN ITEM LENGTH - CHARS
  
*      TEMP REGISTERS USED BY RELGEN
  
 DSPFLG   EQU    T5                DISP CODE NUMBER FLAG
 ANALLIT  EQU    T7                AN ITEM IS AN -ALL- LITERAL FLAG 
 ANBLANK  EQU    T8                AN ITEM IS SPACES FLAG 
 WRDOFF   EQU    T6                WORD OFFSET FOR FWAPLUS SETSY
 LNTHA    EQU    T7                CHAR LENGTH OF ITEM A FOR COMPARE
 LNTHB    EQU    T8                DITTO FOR ITEM B 
 IFA      IFEQ   OP.BDP,OP.YES
 NCA      EQU    T9                NEW CHAR ADDR
 NBCPA    EQU    T11
 NBCPB    EQU    T12
 WRDOFFC  EQU    T13               WORD OFFSET FOR FWCPLUS SETSY
 TEMP     EQU    T14
 USECU    EQU    T15         USE COMPARE UNCOLLATED 
  
 IFA      ENDIF 
  
  
 LOCXX    EQU    T1                LOCALXX TAGS 
 LOCXY    EQU    T10               LOCALXY TAGS 
  
  
 CVB0     EQU    R0                B0 HDW REGISTER
 CVB1     EQU    R1                B1=1 HDW REGISTER
  
* 
*         ENTRY POINTS
* 
 RELGEN   KNIL   CGEQUAL           EQUALS 
 RELGEN   KNIL   CGGREAT           GREATER
 RELGEN   KNIL   CGLESS            LESS 
 RELGEN   KNIL   CGNOTEQ           NOT EQUALS 
 RELGEN   KNIL   CGNOTGT           NOT GREATER
 RELGEN   KNIL   CGNOTLT           NOT LESS 
 RELGEN   KNIL   CGCOMPA           COMPARE (GENERATED IN -SEARCH ALL-)
* 
 CLASSGEN KNIL   CGALPHA           ALPHABETIC 
 CLASSGEN KNIL   CGNUMER           NUMERIC
 CLASSGEN KNIL   CGNOTAL           NOT ALPHABETIC 
 CLASSGEN KNIL   CGNOTNU           NOT NUMERIC
* 
 SIGNGEN  KNIL   CGPOSIT           POSITIVE 
 SIGNGEN  KNIL   CGNEGAT           NEGATIVE 
 SIGNGEN  KNIL   CGNOTPO           NOT POSITIVE 
 SIGNGEN  KNIL   CGNOTNE           NOT NEGATIVE 
* 
 SWITCHGN KNIL   CGSWITC           SWITCH-NAME
 SWITCHGN KNIL   CGNOTSS           NOT SWITCH-NAME
* 
* 
*         EXTERNAL REFS 
* 
 ADNAT    LINK   ADNAT
 BINVAL   LINK   BINVAL 
 CGSUB    LINK   CGSUB
 CLIT2RN  LINK   CLIT2RN
 CPYDNAT  LINK  CPYDNAT 
 GETSZVG  LINK   CGGTSZV           GET SIZE OF VARIABLE GROUP ITEM
 LOADIX   LINK   LOADIX 
 MOVER    LINK   CGMOVE 
 SUBDNAT  LINK   SUBDNAT
 SUBLOAD  LINK   SUBLOAD
 SUBREF   LINK   SUBREF 
 LOADC4   LINK   CGLOAD4
* 
* 
  
  
* 
*         MISC DEFNS: 
* 
 CONERR2  EQU    810               UNKNOWN CONDITION
 CONERR3  EQU    811               UNKNOWN DATA TYPE
 CONERR4  EQU    812               ILLEGAL COMPARE
 RGSIZE   EQU    20                MAX SIZE ITEM TO COMPARE IN REGISTER 
 MWDLNTH  EQU    10                MACHINE WD LNTH - CHARS
 #1270    CONSTANT  1270
  
 LOCALXX  SETSY  (LOCAL$OF,T1)     T1 WILL HOLD THE LOCAL LABEL NUMBER
 LOCALXY  SETSY  (LOCAL$OF,T10)    T10 WILL HOLD LOCLAB NUMBER
 FWAPLUS  SETSY  (FWA$OF,CONREGB),T6   T6 HOLDS WORD OFFSET 
 FWCPLUS  SETSY  (FWA$OF,CONREGC),T13  FOR USE WITH CONREGC 
 TMPPLUS  SETSY  (EXT$OF,C.TEMP),T6    T6 USED FOR OFFSET 
 CBPRGCS  SETSY  (EXT$OF,C.PRGCS) 
 CPBLANK  SETSY  (EXT$OF,C.BLANK) 
 CPSTRP   SETSY  (EXT$OF,C.STRP)
 CPZERO   SETSY  (EXT$OF,C.ZEROS)  C.ZEROS#C.ZERO 
 CBTEMP   SETSY  (EXT$OF,C.TEMP)
 CPLOVAL  SETSY  (EXT$OF,C.LOVAL),T6   T6 HOLDS WORD OFFSET 
 CPFILLZ  SETSY  (EXT$OF,C.FILLZ),T2   T2 HOLDS WORD OFFSET 
  
  
          TITLE  RELGEN - RELATIONAL CONDITIONS 
* 
**        RELGEN - RELATIONAL CONDITIONS
*                IF <NOT> EQUAL 
*                IF <NOT> LESS
*                IF <NOT> GREATER 
* 
* 
*         THIS GENERATOR IS STRUCTURED AROUND THE DATA TYPES
*                BEING COMPARED.  EACH MAJOR SECTION IS LABELED WITH
*                A TAG OF THE FORM XXVSYY, WHERE XX IS THE TYPE OF THE
*                FIRST ITEM AND YY IS THE TYPE OF THE SECOND. 
* 
*                            DATA TYPE ABREVIATIONS:  
*                AN - ALPHANUMERIC (INCLUDES ALPHABETIC + EDITED TYPES) 
*                ND - NUMERIC DISPLAY 
*                NB - NUMERIC BINARY (COMP-1 AND INDEX DATA ITEMS)
*                 - AND COMP-4 ITEMS
*                NF - NUMERIC FLOATING (COMP-2) 
*                IX - INDEX NAME
* 
*                XX IS USED AT THE FIRST LEVEL STRUCTURE TO REPRESENT 
*                ALL POSSIBLE DATA TYPES. 
* 
 RELGEN   EGO    1
  
          GOTOCASE (TYPEOF,CONREGB) 
            CASE   ALPHNUM,ANVSXX 
            CASE   COMP,NDVSXX
            CASE   GROUP,ANVSXX 
            CASE   ALPHABET,ANVSXX
            CASE   COMP1,NBVSXX 
            CASE   COMP4,NBVSXX 
            CASE   INDXDATA,NBVSXX
            CASE   INDXNAME,IXVSXX
            CASE   ALPHEDIT,ANVSXX
            CASE   ALPNUMED,ANVSXX
            CASE   NUMEDIT,ANVSXX 
            CASE   COMP2,NFVSXX 
            CASE   VARGROUP,ANVSXX
            CASE   DPCOMP2,NFVSXX 
            CASE   BOOLDSP,BDVSXX 
          ENDCASE 
  
          ERROR  CONERR3           UNKNOWN DATA TYPE
  
  
 ANVSXX   EJECT 
* 
**        ANVSXX - ALPHANUMERIC VS OTHER DATA TYPE
* 
 ANVSXX   EGO    2
  
          GOTOCASE (TYPEOF,CONREGC) 
            CASE   ALPHNUM,ANVSAN 
            CASE   GROUP,ANVSAN 
            CASE   COMP,ANVSND
            CASE   VARGROUP,ANVSAN
            CASE   ALPHABET,ANVSAN
            CASE   ALPHEDIT,ANVSAN
            CASE   ALPNUMED,ANVSAN
            CASE   NUMEDIT,ANVSAN 
            CASE   COMP1,ANVSNB 
            CASE   COMP4,ANVSNB 
            CASE   INDXDATA,ANVSNB
            CASE   INDXNAME,ANVSIX
          ENDCASE 
  
          ERROR  CONERR4           ILLEGAL COMPARISON 
  
  
 BDVSXX   EJECT 
* 
**    BDVSXX - BOOLEAN DISPLAY VS OTHER 
* 
 BDVSXX   EGO 2 
          GOTOCASE (TYPEOF,CONREGC) 
            CASE   BOOLDSP,BDVSBD 
          ENDCASE 
          ERROR  CONERR4
 NDVSXX   EJECT 
* 
*         NDVSXX - NUMERIC DISPLAY VS OTHER DATA TYPE 
* 
*                ONLY LEGAL COMPARISONS ARE CHECKED FOR,
*                THE OTHERS, IF THEY OCCUR, FALL THRU TO CONERR4
* 
  
 NDVSXX   EGO    2
  
          GOTOCASE (TYPEOF,CONREGC) 
            CASE   COMP,NDVSND
            CASE   COMP1,NDVSNB 
            CASE   COMP4,NDVSNB 
            CASE   ALPHNUM,NDVSAN 
            CASE   GROUP,NDVSAN 
            CASE   COMP2,NDVSNF 
            CASE   INDXNAME,NDVSIX
            CASE   INDXDATA,NDVSNB
            CASE   ALPHABET,NDVSAN
            CASE   ALPHEDIT,NDVSAN
            CASE   ALPNUMED,NDVSAN
            CASE   NUMEDIT,NDVSAN 
            CASE   VARGROUP,NDVSAN
            CASE   DPCOMP2,NDVSNF 
          ENDCASE 
  
          ERROR  CONERR4           ILLEGAL COMPARISON 
  
  
 NBVSXX   EJECT 
* 
*         NBVSXX - NUMERIC BINARY (COMP-1) VS OTHER DATA TYPE 
*                - OR COMP-4 VS OTHER DATA TYPES
* 
*                ONLY LEGAL COMPARISONS ARE CHECKED FOR,
*                OTHERS FALL THRU TO ERROR
  
 NBVSXX   EGO    2
  
          GOTOCASE (TYPEOF,CONREGC) 
            CASE   COMP1,NBVSNB 
            CASE   COMP4,NBVSNB 
            CASE   COMP,NBVSND
            CASE   INDXNAME,NBVSIX
            CASE   INDXDATA,NBVSNB
            CASE   COMP2,NBVSNF 
            CASE   DPCOMP2,NBVSNF 
            CASE   ALPHNUM,NBVSAN 
            CASE   GROUP,NBVSAN 
            CASE   ALPHABET,NBVSAN
            CASE   ALPHEDIT,NBVSAN
            CASE   ALPNUMED,NBVSAN
            CASE   NUMEDIT,NBVSAN 
          ENDCASE 
  
          ERROR  CONERR4           ILLEGAL COMPARISON 
  
  
 NFVSXX   EJECT 
* 
*         NFVSXX - NUMERIC FLOATING (COMP-2) VS OTHER DATA TYPE 
* 
*                ONLY LEGAL COMPARISONS WILL BE CHECKED FOR,
*                ILLEGAL COMPARISONS WILL RECIEVE AN ERROR
* 
  
 NFVSXX   EGO    2
  
          GOTOCASE (TYPEOF,CONREGC) 
            CASE   COMP2,NFVSNF 
            CASE   COMP1,NFVSNB 
            CASE   COMP4,NFVSNB 
            CASE   COMP,NFVSND
            CASE   INDXNAME,NFVSIX
            CASE   INDXDATA,NFVSNB
            CASE   DPCOMP2,NFVSNF 
          ENDCASE 
  
          ERROR  CONERR4           ILLEGAL COMPARISON 
  
  
 IXVSXX   SPACE  4
* 
*         IXVSXX - INDEX NAME VS OTHER DATA TYPE
* 
*                SINCE INDEX NAMES ARE STORED IN A SPECIAL FORMAT,
*                THEY CANNOT BE SIMPLY HANDLED AS COMP-1 ITEMS. 
*                INDEX NAMES CONTAIN: 
*                            VFD   30/OCC NR*LNTH,30/OCC NR 
* 
  
 IXVSXX   EGO    2
  
          GOTOCASE (TYPEOF,CONREGC) 
            CASE   INDXNAME,IXVSIX
            CASE   INDXDATA,IXVSNB
            CASE   COMP1,IXVSNB 
            CASE   COMP4,IXVSNB 
            CASE   COMP,IXVSND
            CASE   ALPHNUM,IXVSAN 
            CASE   COMP2,IXVSNF 
            CASE   DPCOMP2,IXVSNF 
            CASE   ALPHABET,IXVSAN
            CASE   ALPHEDIT,IXVSAN
            CASE   ALPNUMED,IXVSAN
            CASE   NUMEDIT,IXVSAN 
            CASE   GROUP,IXVSAN 
          ENDCASE 
  
          ERROR  CONERR4           ILLEGAL COMPARISON 
  
  
 ANVSAN   EJECT 
* 
**        ANVSAN - ALPHANUMERIC TO ALPHANUMERIC COMPARISON
* 
*         WE SPECIAL CASE COMPARES WHEN THE VERB IS EQUAL OR NOT-EQUAL, 
*                BOTH ITEMS ARE 20 CHARS OR LESS AND THE
*                "EQUAL CHARS IN COLLATING SEQUENCE" FLAG (EQCHFLG) 
*                IS NOT SET.  IN THIS CASE, WE LOAD BOTH ITEMS IN 
*                REGISTERS, DO AN EXCLUSIVE-OR  AND BRANCH. 
* 
*                OTHERWISE, WE CALL   C.BCDCM  OR C. LITCM. 
* 
*                AT THIS LEVEL, WE CONFINE OURSELVES TO DETERMINING 
*                WHICH CASE WE HAVE.
* 
* 
 ANVSAN   EGO    3
          MAXZ   (BYTLENOF,CONREGB),(BYTLENOF,CONREGC),MXLNTH 
 IFB      IFEQ   OP.BDP,OP.NO      NO CMU 
  
          IFZ    (MXLNTH,GT,RGSIZE),ANVSAN4      ITEMS TOO BIG
          IFZ    (CCTBIT,ANALSO),ANVSAN4    EQUAL CHARS IN COLL SEQ 
          IFTHEN ((GSCODEOF,CONREGA),NE,GEQUAL) 
            IFZ    ((GSCODEOF,CONREGA),NE,GNOTEQ),ANVSAN4 
          ENDIFZ
          IFZ    ((GCODEOF,CONREGB),NE,GLITREF),ANVSAN3 
          IFZ    ((SPACESOF,CONREGB),NE,0),ANVSAN3
          IFZ    ((LATALLOF,CONREGB),NE,0),ANVSAN4
 ANVSAN3  LABEL 
          IFZ    ((GCODEOF,CONREGC),NE,GLITREF),ANVSAN5 
          IFZ    ((SPACESOF,CONREGC),NE,0),ANVSAN5
          IFZ    ((LATALLOF,CONREGC),NE,0),ANVSAN4
 ANVSAN5  LABEL 
          CALLZ  REGSUB 
 IFB      ELSE               YES CMU
  
          IFZ    ((TYPEOF,CONREGB),EQ,VARGROUP),ANVSAN4 
          IFZ    ((TYPEOF,CONREGC),EQ,VARGROUP),ANVSAN4 
          IFZ    ((GCODEOF,CONREGB),NE,GLITREF),ANVSAN1 
          IFZ    ((SPACESOF,CONREGB),NE,0),ANVSAN1
          IFZ    ((LATALLOF,CONREGB),NE,0),ANVSAN4
  
 ANVSAN1  LABEL 
          IFZ    ((GCODEOF,CONREGC),NE,GLITREF),ANVSAN2 
          IFZ    ((SPACESOF,CONREGC),NE,0),ANVSAN2
          IFZ    ((LATALLOF,CONREGC),NE,0),ANVSAN4
  
 ANVSAN2  LABEL 
          IFZ    ((GSCODEOF,CONREGB),NE,0),ANVSAN4    ITEM SUBSCRIPTED
          IFZ    ((GSCODEOF,CONREGC),NE,0),ANVSAN4    SO GO CALLOBJ 
          IFZ    ((BYTLENOF,CONREGB),GT,#1270),ANVSAN4     EASIER TO
          IFZ    ((BYTLENOF,CONREGC),GT,#1270),ANVSAN4     USE BCDCM
          MOVEZ  0,DSPFLG 
  
          CALLZ  GENCC
          RETURN
  
 IFB      ENDIF 
          RETURN
 ANVSAN4  LABEL 
          CALLZ  CALLOBJ
          RETURN
 ANVSND   EJECT 
* 
**        ANVSND - ALPHANUMERIC VS DISPLAY NUMERIC INTEGER
* 
*                WE USE ALMOST THE SAME PROCESSING AS ANVSAN, 
*                WITH THE EXCEPTION THAT IF AN OBJECT ROUTINE 
*                COMPARISON IS TO BE DONE AND THE AN ITEM IS
*                ELEMENTARY, WE MUST STRIP THE SIGN FROM THE NUMERIC
*                ITEM BEFORE THE COMPARE.  TO DO THIS WE MOVE THE 
*                ND ITEM TO C.TEMP AND COMPARE FROM THERE.
* 
* 
 ANVSND   EGO    3
 IFC      IFEQ   OP.BDP,OP.NO      NO CMU 
  
          IFZ    ((BYTLENOF,CONREGB),GT,RGSIZE),ANVSND2 
          IFZ    (CCTBIT,ANALSO),ANVSND2
          IFTHEN ((GSCODEOF,CONREGA),NE,GEQUAL) 
            IFZ    ((GSCODEOF,CONREGA),NE,GNOTEQ),ANVSND2 
          ENDIFZ
          IFZ    ((GSCODEOF,CONREGB),NE,0),ANVSND2    IF SUBSCRIPTED..
          IFZ    ((GSCODEOF,CONREGC),NE,0),ANVSND2    GO CALL OBJ RTN 
          CALLZ  REGSUB 
          RETURN
 ANVSND2  LABEL 
 IFC      ELSE
          IFZ    ((TYPEOF,CONREGB),EQ,VARGROUP),ANVSND8 
 IFC      ENDIF 
          IFZ    ((TYPEOF,CONREGB),NE,GROUP),ANVSND4
 IFD      IFEQ   OP.BDP,OP.YES     CMU ON 
          IFTHEN ((BYTLENOF,CONREGB),GT,#1270)
            CALLZ  CALLOBJ
            RETURN
          ENDIFZ
          IFTHEN ((GSCODEOF,CONREGB),EQ,0)       NO SUBSCRIPTS
            ANDIF  ((GSCODEOF,CONREGC),EQ,0)
            MOVEZ  0,DSPFLG 
            CALLZ  GENCC
            RETURN
          ELSEZ 
            CALLZ  CALLOBJ
          ENDIFZ
 IFD      ELSE
          CALLZ  CALLOBJ
 IFD      ENDIF 
          RETURN
 ANVSND4  LABEL 
          NOTE   ANVSND 
  
          IFTHEN ((TYPEOF,CONREGC),EQ,COMP) 
            IFZ    ((SIGNOF,CONREGC),EQ,0),ANVSAN 
          ENDIFZ
          MOVEZ  0,ANALLIT   CLEAR -ALL- LIT FLAG 
          MOVEZ  0,ANBLANK   CLEAR SPACES FLAG
          IFZ    ((GCODEOF,CONREGB),NE,GLITREF),ANVSND6 
          IFTHEN ((LATALLOF,CONREGB),NE,0)
            MOVEZ  1,ANALLIT
          ENDIFZ
  
          IFTHEN ((SPACESOF,CONREGB),NE,0)
            MOVEZ  0,ANALLIT
            MOVEZ  1,ANBLANK
          ENDIFZ
  
 ANVSND6  LABEL 
          PUSH   ANALLIT,ANBLANK
          MOVEZ  CONREGD,CONREGI   SAVE BRANCH FLD
          MOVEZ  CONREGB,CONREGK
          MOVEZ  (EQUALS,CREG11),CONREGT
          CALLZ  ADNAT
          MOVEZ  CONREGC,CONREGB
          MOVEZ  (EQUALS,CREG11),CONREGC
  
*      SET UP DUMMY DNAT- 
  
          MOVEZ  ALPHNUM,(TYPEOF,CONREGC) 
          MAXZ   (BYTLENOF,CONREGK),(BYTLENOF,CONREGB),MXLNTH 
          MOVEZ  MXLNTH,(BYTLENOF,CONREGC)
          MOVEZ  0,(BCPOF,CONREGC)
          CALLZ  MOVER
          POP    ANALLIT,ANBLANK
          GEN    XMIT,(VREGOF,CVREGA),(TREGOF,CONREGC)
          IFTHEN (MXLNTH,GT,MWDLNTH)
            GEN    XMIT,(VREGOF,CVREGB),(TREGP1OF,CONREGC)
          ENDIFZ
          GEN    SSRBPK,CVREGA,CVB0,CBTEMP
          IFTHEN (MXLNTH,GT,MWDLNTH)
            GEN    SSRAPB,CVREGB,CVREGA,CVB1
          ENDIFZ
          CALLZ  SUBDNAT
 IFE      IFEQ   OP.BDP,OP.YES     GOT A CMU
          IFZ    ((GSCODEOF,CONREGK),NE,0),ANVSND8
          IFZ    (ANALLIT,NE,0),ANVSND8          GO CALL C.LITCM
          IFZ    ((BYTLENOF,CONREGB),GT,#1270),ANVSND8     TOO BIG
          MOVEZ  2,DSPFLG 
          MOVEZ  CONREGK,CONREGB
          CALLZ  GENCC
          RETURN
  
 ANVSND8  LABEL 
 IFE      ENDIF 
  
*      BUILD CALL TO C.BCDCM
  
          IFTHEN ((GSCODEOF,CONREGK),NE,0)       VAR SUBSCR OR REF MOD
            MOVEZ  CONREGK,P2 
            CALLZ  SUBREF 
            MOVEZ  P3,CVREGA
            GEN    SBXPB,(VREGOF,CVREGE),P4 
          ELSEZ 
            GEN    SXBPK,(VREGOF,CVREGA),,(BCPOF,CONREGK) 
          ENDIFZ
          GEN    SXBPB,(VREGOF,CVREGB),CVB0,CVB0
          IFZ    (ANALLIT,NE,0),ANVSND10
          IFTHEN (ANBLANK,NE,0) 
            GEN    SBBPK,(VREGOF,CVREGC),,CPBLANK 
          ELSEZ 
            GEN    SBBPK,(VREGOF,CVREGC),,((FWA$OF,CONREGK))
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGD),CVB0,CBTEMP
  
          IFTHEN ((TYPEOF,CONREGK),EQ,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGK),EQ,0)       NO REF MODIFIER
            MOVEZ  CONREGK,CONREGM
            CALLZ  GETSZVG
            GEN    SBXPB,(VREGOF,CVREGE),,P1
          ENDIFZ
          IFTHEN ((TYPEOF,CONREGK),NE,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGK),EQ,0)
            GEN    SBBPK,(VREGOF,CVREGE),,(BYTLENOF,CONREGK)
          ENDIFZ
  
          GEN    SBBPK,(VREGOF,CVREGF),CVB0,(BYTLENOF,CONREGC)
          GENOBJ N=C.BCDCM,I=(CVREGA,CVREGB,CVREGC,CVREGD,CVREGE,CVREGF)
,,O=((VREGOF,CVREGA)) 
          CALLZ  BRGBRNCH          BUILD B-REG BRANCH 
          RETURN
  
 ANVSND10 SPACE  4
 ANVSND10 LABEL 
          NOTE   ANVSND10 
          IFTHEN ((FIGVALOF,CONREGK),NE,0)       C.F. HI/LO VALUES
            SUBZ   (FIGVALOF,CONREGK),1,T6       BUILD OFFSET 
            GEN    SBBPK,(VREGOF,CVREGC),,CPLOVAL 
            GEN    SBBPK,(VREGOF,CVREGE),,10
          ELSEZ 
            GEN    SBBPK,(VREGOF,CVREGC),,((FWA$OF,CONREGK))
            GEN    SBBPK,(VREGOF,CVREGE),,(BYTLENOF,CONREGK)
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGD),,CBTEMP
          GEN    SBBPK,(VREGOF,CVREGF),,(BYTLENOF,CONREGC)
          GEN    SBBPB,(VREGOF,CVREGG),CVB0,CVB0
  
          GENOBJ N=C.LITCM,I=(CVREGA,CVREGB,CVREGC,CVREGD,CVREGE,CVREGF,
,CVREGG),O=((VREGOF,CVREGA))
          CALLZ  BRGBRNCH 
          RETURN
  
 ANVSNB   SPACE  4
* 
*         ANVSNB
* 
 ANVSNB   EGO    3
          ERROR  CONERR4           ILLEGAL COMPARE
  
  
 ANVSIX   SPACE  4
* 
*         ANVSIX
* 
 ANVSIX   EGO    3
          ERROR  CONERR4           ILLEGAL COMPARE
  
  
 BDVSBD   EJECT 
 BDVSBD   EGO 3 
          NOTE   BDVSBD 
*    CHECK FOR POSSIBLE IN-LINE COMPARE 
          IFTHEN ((GSCODEOF,CONREGB),EQ,0)       NOT REFERENCE MODIFIED 
          ANDIF  ((GSCODEOF,CONREGC),EQ,0)       NOT REFERENCE MODIFIED 
          ANDIF  ((BYTLENOF,CONREGB),EQ,(BYTLENOF,CONREGC)) 
          ANDIF  ((BYTLENOF,CONREGB),LE,RGSIZE) 
            CALLZ   REGSUB
            RETURN
          ENDIFZ
          ORZ    (LATALLOF,CONREGC),(LATALLOF,CONREGB),T1 
          IFTHEN (T1,NE,0)   EITHER COMPARAND ALL LITERAL 
            CALLZ  CALLOBJ   WILL GENERATE C.LITCM CALL 
            RETURN
          ENDIFZ
          IFTHEN ((GSCODEOF,CONREGB),NE,0)
            MOVEZ  CONREGB,P2 
            CALLZ  SUBREF 
            MOVEZ  P3,CVREGA
            GEN    SBXPB,(VREGOF,CVREGE),P4 
          ELSEZ 
            GEN    SXBPK,(VREGOF,CVREGA),,(BCPOF,CONREGB) 
            GEN    SBBPK,(VREGOF,CVREGE),,(BYTLENOF,CONREGB)
          ENDIFZ
          IFTHEN ((GSCODEOF,CONREGC),NE,0)
            MOVEZ  CONREGC,P2 
            CALLZ  SUBREF 
            MOVEZ  P3,CVREGB
            GEN    SBXPB,(VREGOF,CVREGF),P4 
          ELSEZ 
            GEN    SXBPK,(VREGOF,CVREGB),,(BCPOF,CONREGC) 
            GEN    SBBPK,(VREGOF,CVREGF),,(BYTLENOF,CONREGC)
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGC),,((FWA$OF,CONREGB))
          GEN    SBBPK,(VREGOF,CVREGD),,((FWA$OF,CONREGC))
          GENOBJ N=C.BLDCM,I=(CVREGA,CVREGB,CVREGC,CVREGD,CVREGE,CVREGF)
,,O=((VREGOF,CVREGA)) 
          MOVEZ  CONREGD,CONREGI
          CALLZ  BRGBRNCH 
          RETURN
 NDVSAN   EJECT 
* 
**        NDVSAN - DISPLAY NUMERIC INTEGER VS ALPHANUMERIC
* 
*                WE USE THE SAME TECHNIQUE AS IN ANVSND EXCEPT
*                THAT WE PLAY WITH CONREGB INSTEAD OF CONREGC.
* 
 NDVSAN   EGO    3
 IFF      IFEQ   OP.BDP,OP.NO      NO CMU 
  
          IFZ    ((BYTLENOF,CONREGC),GT,RGSIZE),NDVSAN2 
          IFZ    (CCTBIT,ANALSO),NDVSAN2
          IFTHEN ((GSCODEOF,CONREGA),NE,GEQUAL) 
            IFZ    ((GSCODEOF,CONREGA),NE,GNOTEQ),NDVSAN2 
          ENDIFZ
          IFZ    ((GSCODEOF,CONREGB),NE,0),NDVSAN2    IF SUBSCRIPTS,
          IFZ    ((GSCODEOF,CONREGC),NE,0),NDVSAN2    GO CALLOBJ
          CALLZ  REGSUB 
          RETURN
 NDVSAN2  LABEL 
 IFF      ELSE
          IFZ    ((TYPEOF,CONREGC),EQ,VARGROUP),NDVSAN8 
 IFF      ENDIF 
          IFZ    ((TYPEOF,CONREGC),NE,GROUP),NDVSAN4
 IFG      IFEQ   OP.BDP,OP.YES     CMU ON 
          IFTHEN ((BYTLENOF,CONREGC),GT,#1270)
            CALLZ  CALLOBJ
            RETURN
          ENDIFZ
          IFTHEN ((GSCODEOF,CONREGC),EQ,0)       NO SUBSCRIPTS
            ANDIF  ((GSCODEOF,CONREGB),EQ,0)
            MOVEZ  0,DSPFLG 
            CALLZ  GENCC
            RETURN
          ELSEZ 
            CALLZ  CALLOBJ
          ENDIFZ
 IFG      ELSE
          CALLZ  CALLOBJ
 IFG      ENDIF 
          RETURN
 NDVSAN4  LABEL 
          NOTE   NDVSAN 
  
          IFTHEN ((TYPEOF,CONREGB),EQ,COMP) 
            IFZ    ((SIGNOF,CONREGB),EQ,0),ANVSAN 
          ENDIFZ
          MOVEZ  0,ANALLIT   CLEAR -ALL- LIT FLAG 
          MOVEZ  0,ANBLANK   CLEAR SPACES FLAG
          IFZ    ((GCODEOF,CONREGC),NE,GLITREF),NDVSAN6 
          IFTHEN ((LATALLOF,CONREGC),NE,0)
            MOVEZ  1,ANALLIT
          ENDIFZ
  
          IFTHEN ((SPACESOF,CONREGC),NE,0)
            MOVEZ  0,ANALLIT
            MOVEZ  1,ANBLANK
          ENDIFZ
  
 NDVSAN6  LABEL 
          PUSH   ANALLIT,ANBLANK
          MOVEZ  CONREGD,CONREGI   SAVE BRANCH FIELD
          MOVEZ  CONREGC,CONREGK   SAVE REGC
          MOVEZ  (EQUALS,CREG11),CONREGT
          CALLZ  ADNAT
          MOVEZ  (EQUALS,CREG11),CONREGC
  
*      SET UP DUMMY DNAT
  
          MOVEZ  ALPHNUM,(TYPEOF,CONREGC) 
          MAXZ   (BYTLENOF,CONREGB),(BYTLENOF,CONREGK),MXLNTH 
          MOVEZ  MXLNTH,(BYTLENOF,CONREGC)
          MOVEZ  0,(BCPOF,CONREGC)
          CALLZ  MOVER
          POP    ANALLIT,ANBLANK
          GEN    XMIT,(VREGOF,CVREGA),(TREGOF,CONREGC)
          IFTHEN (MXLNTH,GT,MWDLNTH)
            GEN    XMIT,(VREGOF,CVREGB),(TREGP1OF,CONREGC)
          ENDIFZ
          GEN    SSRBPK,CVREGA,CVB0,CBTEMP
          IFTHEN (MXLNTH,GT,MWDLNTH)
            GEN    SSRAPB,CVREGB,CVREGA,CVB1
          ENDIFZ
          CALLZ  SUBDNAT
 IFH      IFEQ   OP.BDP,OP.YES     GOT A CMU
          IFZ    ((GSCODEOF,CONREGK),NE,0),NDVSAN8
          IFZ    (ANALLIT,NE,0),NDVSAN8          GO CALL C.LITCM
          IFZ    ((BYTLENOF,CONREGC),GT,#1270),NDVSAN8     TOO BIG
          MOVEZ  1,DSPFLG 
          MOVEZ  CONREGK,CONREGC
          CALLZ  GENCC
          RETURN
  
 NDVSAN8  LABEL 
 IFH      ENDIF 
  
*      BUILD CALL TO C.BCDCM
  
          GEN    SXBPB,(VREGOF,CVREGA),CVB0,CVB0
          IFTHEN ((GSCODEOF,CONREGK),NE,0)
            MOVEZ  CONREGK,P2 
            CALLZ  SUBREF 
          MOVEZ  P3,CVREGB
          GEN    SBXPB,(VREGOF,CVREGF),P4 
          ELSEZ 
            GEN    SXBPK,(VREGOF,CVREGB),,(BCPOF,CONREGK) 
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGC),CVB0,CBTEMP
          IFZ    (ANALLIT,NE,0),NDVSAN10
          IFTHEN (ANBLANK,NE,0) 
            GEN    SBBPK,(VREGOF,CVREGD),,CPBLANK 
          ELSEZ 
            GEN    SBBPK,(VREGOF,CVREGD),,((FWA$OF,CONREGK))
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGE),CVB0,(BYTLENOF,CONREGC)
  
          IFTHEN ((TYPEOF,CONREGK),EQ,VARGROUP) 
            MOVEZ  CONREGK,CONREGM
            CALLZ  GETSZVG
            GEN    SBXPB,(VREGOF,CVREGF),,P1
          ENDIFZ
          IFTHEN ((TYPEOF,CONREGK),NE,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGK),EQ,0)
          GEN    SBBPK,(VREGOF,CVREGF),,(BYTLENOF,CONREGK)
          ENDIFZ
  
          GENOBJ N=C.BCDCM,I=(CVREGA,CVREGB,CVREGC,CVREGD,CVREGE,CVREGF)
,,O=((VREGOF,CVREGA)) 
          CALLZ  BRGBRNCH          GO BRANCH
          RETURN
  
 NDVSAN10 SPACE  4
 NDVSAN10 LABEL 
          NOTE   NDVSAN10 
          IFTHEN ((FIGVALOF,CONREGK),NE,0)       C.F. HI/LO VALUES
            SUBZ   (FIGVALOF,CONREGK),1,T6       BUILD OFFSET 
            GEN    SBBPK,(VREGOF,CVREGD),,CPLOVAL 
            GEN    SBBPK,(VREGOF,CVREGF),,10
          ELSEZ 
            GEN    SBBPK,(VREGOF,CVREGD),,((FWA$OF,CONREGK))
            GEN    SBBPK,(VREGOF,CVREGF),,(BYTLENOF,CONREGK)
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGC),,CBTEMP
          GEN    SBBPK,(VREGOF,CVREGE),,(BYTLENOF,CONREGC)
          GEN    SBBPB,(VREGOF,CVREGG),CVB0,CVB1
  
          GENOBJ N=C.LITCM,I=(CVREGA,CVREGB,CVREGC,CVREGD,CVREGE,CVREGF,
,CVREGG),O=((VREGOF,CVREGA))
          CALLZ  BRGBRNCH 
          RETURN
  
 NBVSAN   SPACE  4
* 
*         NBVSAN
* 
 NBVSAN   EGO    3
          ERROR  CONERR4           ILLEGAL COMPARE
  
  
 IXVSAN   SPACE  4
* 
*         IXVSAN
* 
 IXVSAN   EGO    3
          ERROR  CONERR4           ILLEGAL COMPARE
  
  
 NDVSND   EJECT 
* 
**        NDVSND - NUMERIC VS NUMERIC COMPARES
* 
*                ALL NUMERIC TO NUMERIC (EXCEPT INDEX NAMES) COMPARISONS
*                ARE HANDLED HERE.
* 
*                WE SET UP REGD WITH A DUMMY DNAT, CALL GSUB TO 
*                BUILD THE SUBTRACT + BRANCH ON THE RESULT
* 
* 
  
 NDVSND   EGO    3
 IFHA     IFEQ   OP.BDP,OP.NO      NO CMU 
**        NDVSND - NON-CMU CODE 
*                WE CAN AVIOD DOING A FULL ARITHMETIC SUBTRACT IF 
*                            BOTH FIELDS: 
*                ARE UNSIGNED,
*                ARE UNSUBSCRIPTED, 
*                ARE LE 9 CHARS,
*                HAVE THE SAME DEC POINT LOCATIONS. 
* 
  
          IFZ    ((SIGNOF,CONREGB),NE,0),NDVSND2
          IFZ    ((SIGNOF,CONREGC),NE,0),NDVSND2
          IFZ    ((GSCODEOF,CONREGB),NE,0),NDVSND2         SUBSCR.
          IFZ    ((GSCODEOF,CONREGC),NE,0),NDVSND2         SUBSCR.
          IFZ    ((CCTBIT,LBZ),NE,0),NDVSND2     LBZ OPTION ON
          IFZ    ((POINTOF,CONREGB),EQ,(POINTOF,CONREGC)),NDVSND1 
  
          IFTHEN ((POINTOF,CONREGB),LT,(POINTOF,CONREGC)) 
            SUBZ   (POINTOF,CONREGC),(POINTOF,CONREGB),T8 
            ADDZ   (NUMLENOF,CONREGB),T8,T1 
            IFZ    (T1,GT,9),NDVSND2
          ELSEZ 
            SUBZ   (POINTOF,CONREGB),(POINTOF,CONREGC),T8 
            ADDZ   (NUMLENOF,CONREGC),T8,T1 
            IFZ    (T1,GT,9),NDVSND2
          ENDIFZ
  
 NDVSND1  LABEL 
          IFZ    ((NUMLENOF,CONREGB),GT,9),NDVSND2
          IFZ    ((NUMLENOF,CONREGC),GT,9),NDVSND2
          IFZ    ((NUMLENOF,CONREGB),EQ,(NUMLENOF,CONREGC)),NDVSND1A
          IFTHEN ((GCODEOF,CONREGB),NE,GLITREF) 
          ANDIF  ((GCODEOF,CONREGC),NE,GLITREF) 
            BRANCH NDVSND5
          ENDIFZ
 NDVSND1A LABEL 
  
*      CHECK BOTH FIELDS TO SEE IF THE LITERALS WERE POOLED (MAY NOT BE 
*      POOLED FOR A CONSTANT SUBSCRIPTED ITEM)
          IFTHEN ((GCODEOF,CONREGB),EQ,GLITREF) 
            IFZ    ((MAJMSCOF,CONREGB),EQ,UNLITMSE),NDVSND6 
            IFZ    ((MAJMSCOF,CONREGB),NE,LITMSEC),NDVSND2
          ENDIFZ
  
          IFTHEN ((GCODEOF,CONREGC),EQ,GLITREF) 
            IFZ    ((MAJMSCOF,CONREGC),EQ,UNLITMSE),NDVSND8 
            IFZ    ((MAJMSCOF,CONREGC),NE,LITMSEC),NDVSND2
          ENDIFZ
  
          MOVEZ  CONREGB,CONREGK
          CALLZ  LODSNUM
          MOVEZ  T1,T6
          MOVEZ  CONREGC,CONREGK
          CALLZ  LODSNUM
  
          NOTE   NDVSND 
          IFTHEN ((GCODEOF,CONREGB),EQ,GLITREF) 
            MOVEZ  T6,CVREGC       NO NEED TO MASK..LITS ARE ZERO FILLED
          ELSEZ 
            MOVEZ  (NUMLENOF,CONREGB),T5
            GEN    MASK,(VREGOF,CVREGB),(ARITH7,T5)    60-6*T5
            GEN    LIMP,(VREGOF,CVREGC),T6,CVREGB 
          ENDIFZ
          IFTHEN ((GCODEOF,CONREGC),EQ,GLITREF) 
            MOVEZ  T1,CVREGD
          ELSEZ 
            MOVEZ  (NUMLENOF,CONREGC),T5
            GEN    MASK,(VREGOF,CVREGB),(ARITH7,T5) 
            GEN    LIMP,(VREGOF,CVREGD),CVREGA,CVREGB 
          ENDIFZ
  
          IFTHEN ((POINTOF,CONREGB),NE,(POINTOF,CONREGC)) 
            SUBZ   10,(NUMLENOF,CONREGB),T2 
            MOVEZ  CVREGC,T4
            MOVEZ  CVREGD,T5
            GEN    SLRBPK,(VREGOF,CVREGA),,CPFILLZ
            GEN    LOR,(VREGOF,CVREGC),T4,CVREGA
            GEN    LOR,(VREGOF,CVREGD),T5,CVREGA
          ENDIFZ
  
 NDVSND3A LABEL 
          IFZ    ((POINTOF,CONREGB),EQ,(POINTOF,CONREGC)),NDVSND3B
          MULTZ  T8,6,T8           BUILD SHIFT COUNT
  
          IFTHEN ((POINTOF,CONREGB),LT,(POINTOF,CONREGC)) 
            GEN    SHL,CVREGC,T8
          ELSEZ 
            GEN    SHL,CVREGD,T8
          ENDIFZ
  
 NDVSND3B LABEL 
          GEN    ISUB,(VREGOF,CVREGA),CVREGC,CVREGD 
  
 NDVSND4  LABEL 
          MOVEZ  0,DSPFLG 
          MOVEZ  CONREGD,CONREGI
          CALLZ  SPBRNCH
          RETURN
 NDVSND5  SPACE  4
 NDVSND5  LABEL 
* 
*      NO LITERALS SHOULD COME THRU THIS CODE...
* 
  
          MOVEZ  CONREGB,CONREGK
          CALLZ  LODSNUM
          MOVEZ  T1,T5
          MOVEZ  CONREGC,CONREGK
          CALLZ  LODSNUM
          NOTE   NDVSND5
  
          SUBZ   10,(NUMLENOF,CONREGB),T2 
          MULTZ  T2,6,T3     BIT COUNT FOR MASK 
          GEN    MASK,(VREGOF,CVREGA),T3    BUILD MASK
          GEN    LIMP,(VREGOF,CVREGB),T5,CVREGA 
          GEN    SLRBPK,(VREGOF,CVREGA),,CPFILLZ
          GEN    LOR,(VREGOF,CVREGC),CVREGB,CVREGA    COMPLETE ZERO FILL
  
          SUBZ   10,(NUMLENOF,CONREGC),T2 
          MULTZ  T2,6,T3     MASK COUNT 
          GEN    MASK,(VREGOF,CVREGD),T3
          GEN    LIMP,(VREGOF,CVREGA),T1,CVREGD 
          GEN    SLRBPK,(VREGOF,CVREGB),,CPFILLZ      ZERO FILL 
          GEN    LOR,(VREGOF,CVREGD),CVREGA,CVREGB
  
          BRANCH NDVSND3A    GO SUBTRACT
 NDVSND6  SPACE  4
**        NDVSND6 - SHORT (IMMEDIATE) LIT VS NUMERIC
* 
*                VALUE OF LITERAL STORED IN DN$SHORTLIT IN DNAT 
 NDVSND6  LABEL 
          MOVEZ  CONREGC,CONREGK
          CALLZ  LODSNUM
  
          NOTE   NDVSND6
          MOVEZ  (NUMLENOF,CONREGC),T5
          MOVEZ  (ARITH7,T5),T5        6/-6*T5
          GEN    MASK,(VREGOF,CVREGB),T5
          GEN    LIMP,(VREGOF,CVREGD),CVREGA,CVREGB 
          MOVEZ  (SHOLITOF,CONREGB),T1
          GEN    SXBPK,(VREGOF,CVREGC),0,T1 
          BRANCH NDVSND3A 
 NDVSND8  SPACE  4
**        NDVSND8 - SAME AS NDVSND6 W/ REGS REVERSED
* 
 NDVSND8  LABEL 
          MOVEZ  CONREGB,CONREGK
          CALLZ  LODSNUM
  
          NOTE   NDVSND8
          MOVEZ  (NUMLENOF,CONREGB),T5
          MOVEZ  (ARITH7,T5),T5 
          GEN    MASK,(VREGOF,CVREGB),T5
          GEN    LIMP,(VREGOF,CVREGC),CVREGA,CVREGB 
          MOVEZ  (SHOLITOF,CONREGC),T1
          SUBZ   0,T1,T1     MAKE NEGATIVE
          GEN    SXXPK,(VREGOF,CVREGA),CVREGC,T1
          BRANCH NDVSND4
  
 IFHA     ELSE
  
**        NDVSND - CMU MODE 
*                CMU CODE FOR NDVSND COMPARES ONLY WILL BE
*                            GENERATED IF BOTH FIELDS:  
*                ARE UNSIGNED,
*                ARE NOT SUBSCRIPTED, 
*                HAVE THE SAME LENGTH,
*                HAVE THE SAME DEC PT LOCN. 
* 
  
          IFZ    ((CCTBIT,LBZ),NE,0),NDVSND2
          IFZ    ((SIGNOF,CONREGB),NE,0),NDVSND2
          IFZ    ((SIGNOF,CONREGC),NE,0),NDVSND2
          IFZ    ((GSCODEOF,CONREGB),NE,0),NDVSND2         SUBSCR.
          IFZ    ((GSCODEOF,CONREGC),NE,0),NDVSND2         SUBSCR.
          IFZ    ((NUMLENOF,CONREGB),NE,(NUMLENOF,CONREGC)),NDVSND2 
          IFZ    ((POINTOF,CONREGB),NE,(POINTOF,CONREGC)),NDVSND2 
          IFZ    ((LEVELOF,CONREGB),EQ,TEMPLEVL),NDVSND2  ARITH. EXPRESS
          IFZ    ((LEVELOF,CONREGC),EQ,TEMPLEVL),NDVSND2  ARITH. EXPRESS
  
          NOTE   NDVSND 
          MOVEZ  (BCPOF,CONREGB),NBCPA
          MOVEZ  (BCPOF,CONREGC),NBCPB
          MOVEZ  (BYTLENOF,CONREGB),LNTHA 
          MOVEZ  (BYTLENOF,CONREGC),LNTHB 
  
*      L-POOLER WILL POOL LITS FOR THESE CASES UNLESS THE ITEM IS 
*      SUBSCRIPTED.  HOWEVER, FOR CONSTANT SUBSCRIPTS WE HAVE TO CALL 
*      THE CGEN POOLING FACILITY. 
  
          IFTHEN ((GCODEOF,CONREGB),EQ,GLITREF) 
            ANDIF  ((MAJMSCOF,CONREGB),NE,LITMSEC)
            MOVEZ  (LITREFOF,CONREGB),P1
            MOVEZ  (NUMLENOF,CONREGB),P2
            MOVEZ  (POINTOF,CONREGB),P3 
            MOVEZ  0,P4                          (SIGNOF,CONREGB) = 0 
            CALLZ  CLIT2RN
            MOVEZ  CONREGB,REGT 
            SUBZ   10,LNTHA,NBCPA 
            IFZ    (LNTHA,LE,10),NDVSND4
            MOVEZ  P2,P3
            MOVEZ  P1,P2
            ADDZ   10,NBCPA,NBCPA 
 NDVSND4  LABEL 
            MOVEZ  0,P1 
            EXECUTE LITPOOL 
          ENDIFZ
  
          IFTHEN ((GCODEOF,CONREGC),EQ,GLITREF) 
            ANDIF  ((MAJMSCOF,CONREGC),NE,LITMSEC)
            MOVEZ  (LITREFOF,CONREGC),P1
            MOVEZ  (NUMLENOF,CONREGC),P2
            MOVEZ  (POINTOF,CONREGC),P3 
            MOVEZ  0,P4                          (SIGNOF,CONREGC) = 0 
            CALLZ  CLIT2RN
            MOVEZ  CONREGC,REGT 
            SUBZ   10,LNTHB,NBCPB 
            IFZ    (LNTHB,LE,10),NDVSND7
            MOVEZ  P2,P3
            MOVEZ  P1,P2
            ADDZ   10,NBCPB,NBCPB 
 NDVSND7  LABEL 
            MOVEZ  0,P1 
            EXECUTE LITPOOL 
          ENDIFZ
          GEN    CU$,LNTHB,((FWA$OF,CONREGB)),NBCPA,((FWA$OF,CONREGC)),N
,BCPB,(VREGOF,CVREGA) 
  
          MOVEZ  0,DSPFLG 
          MOVEZ  CONREGD,CONREGI
          CALLZ  SPBRNCH
          RETURN
  
  
 IFHA     ENDIF 
 NDVSND2  SPACE  4
  
 NDVSND2  EGO    3           NON-DISPLAY TYPES COME HERE
          NOTE   NDVSND2
  
 NDVSNB   EQU    NDVSND2
 NDVSNF   EQU    NDVSND2
 NBVSND   EQU    NDVSND2
 NBVSNB   EQU    NDVSND2
 NBVSNF   EQU    NDVSND2
 NFVSND   EQU    NDVSND2
 NFVSNB   EQU    NDVSND2
 NFVSNF   EQU    NDVSND2
  
  
          MOVEZ  CONREGD,CONREGI   SAVE BRANCH FIELD
          PUSH   REGB,REGC
          IFZ    ((GCODEOF,REGC),EQ,GLITREF),NDVSND2C 
          IFZ    ((GCODEOF,REGB),NE,GLITREF),NDVSND20 
          MOVEZ  REGB,REGT   SWAP LITERAL AND DATA ITEM 
          MOVEZ  REGC,REGB
          MOVEZ  REGT,REGC
          CALLZ  INVTREL     INVERT RELATION
 NDVSND2C LABEL 
          IFZ    ((TYPEOF,REGC),EQ,COMP2),NDVSND20
          MOVEZ  REGC,REGT
          CALLZ  BINVAL 
          IFZ    (P1,NE,0),NDVSND20    NOT COMPARE TO ZERO
          IFZ    ((SIGNOF,REGB),EQ,1),NDVSND2A
          IFZ    ((GSCODEOF,CONREGA),EQ,GCOMPARE),NDVSND2A
          IFZ    ((GSCODEOF,CONREGA),EQ,GEQUAL),NDVSND2A
          IFZ    ((GSCODEOF,CONREGA),EQ,GNOTEQ),NDVSND2A
          IFTHEN  ((GSCODEOF,CONREGA),EQ,GGREATER)
            MOVEZ  GNOTEQ,(GSCODEOF,CONREGA)
          BRANCH  NDVSND2A
          ENDIFZ
          IFTHEN ((GSCODEOF,CONREGA),EQ,GNOTGT) 
          MOVEZ  GEQUAL,(GSCODEOF,CONREGA)
          BRANCH  NDVSND2A
          ENDIFZ
          IFTHEN  ((GSCODEOF,CONREGA),EQ,GLESS) 
          IFZ    ((GSCODEOF,CONREGI),EQ,GTRUE),NDVSND2X 
            GEN    EQ$,,,((FWA$OF,CONREGI)) 
            BRANCH  NDVSND2X
          ENDIFZ
          IFTHEN  ((GSCODEOF,CONREGA),EQ,GNOTLT)
           IFZ   ((GSCODEOF,CONREGI),EQ,GFALSE),NDVSND2X
            GEN    EQ$,,,((FWA$OF,CONREGI)) 
            BRANCH  NDVSND2X
          ENDIFZ
 NDVSND2A LABEL 
          PUSH   REGC 
          MOVEZ  CREG11,REGT
          CALLZ  ADNAT
          MOVEZ  REGT,REGC
          MOVEZ  (POINTOF,REGB),(POINTOF,REGC)
          MOVEZ  1,(SIGNOF,REGC)       FORCE TWO WORDS FOR SIZE 10 DISPL
          MOVEZ  (NUMLENOF,REGB),(NUMLENOF,REGC)
          MOVEZ  (TYPEOF,REGB),(TYPEOF,REGC)
          CALLZ  MOVER
          MOVEZ  REGC,REGD
          POP    REGC 
          BRANCH NDVSND21 
 NDVSND20 LABEL 
  
          MOVEZ  (EQUALS,CREG11),CONREGT
          CALLZ  ADNAT
          MOVEZ  (EQUALS,CREG11),CONREGD
  
          CALLZ  CGSUB       DO THE SUBTRACT (B-C)
  
 NDVSND21 LABEL 
          MOVEZ  0,DSPFLG    CLEAR FLAG 
          IFTHEN  ((TYPEOF,CONREGD),EQ,COMP)
            IFZ    ((NUMLENOF,CONREGD),GT,9),NDVSND22 
            GEN    SLRBPK,(VREGOF,CVREGB),CVB0,CPZERO 
            GEN    ISUB,(VREGOF,CVREGA),(TREGOF,CONREGD),CVREGB 
            MOVEZ  1,DSPFLG        SET DISPLAY CODE NR FLAG FOR SPBRNCH 
          ELSEZ 
            MOVEZ  (TREGOF,CONREGD),CVREGA
          ENDIFZ
          CALLZ  SPBRNCH
          CALLZ  SUBDNAT
 NDVSND2X LABEL 
          POP    REGB,REGC
          RETURN
  
 NDVSND22 LABEL 
          CALLZ  DPBRNCH
          BRANCH NDVSND2X 
  
 DPBRNCH  EJECT 
* 
**        DPBRNCH - BUILD BRANCHES FOR D.P. ND ITEMS
* 
*                THERE ARE SIZ POSSIBLE CODE SEQUENCES WE CAN 
*                GENERATE:  
* 
*         CASE 1 (USED BY IF GT/TRUE AND IF NGT/FALSE)
* 
*         NZ     XI,LOCALXX 
*         ZR     XI+1,LOCALXY 
*LOCALXX  PL     XO,TAG            NOTE: USES UNDEBIASED VALUE
*LOCALXY  BSS    0
* 
* 
*         CASE 2 (USED BY IF GT/FALSE AND IF NGT/TRUE)
* 
*         NZ     XI,LOCALXX 
*         ZR     XI+1,TAG 
*LOCALXX  NG     XO,TAG 
* 
* 
*         CASE 3 (USED BY IF EQ/TRUE + IFNEQ/FALSE) 
* 
*         NZ     XI,LOCALXX 
*         ZR     XI+1,TAG 
*LOCALXX  BSS    0
* 
* 
*         CASE 4 (USED BY IF EQ/FALSE + IF NEQ/TRUE)
* 
*         NZ     XI,TAG 
*         NZ     XI+1,TAG 
* 
* 
*         CASE 5 (USED BY LT/TRUE AND NLT/FALSE)
* 
*         NG     XO,TAG 
* 
* 
*         CASE 6 (USED BY IF LT/FALSE AND IF NLT/TRUE)
* 
*         NZ     XI,LOCALXX 
*         ZR     XI+1,TAG 
*LOCALXX  PL     XO,TAG 
* 
* 
*         FOR COMPARE VERBS:  
  
*         NZ     XI,LOCALXX 
*         ZR     XI+1,LOCALXY 
*LOCALXX  PL     XO,TAGD           (USES UNDEBIASED VALUE)
*         NG     XO,TAGE
*LOCALXY  BSS    0
* 
* 
* 
* 
*                WE EXPECT CONREGD TO CONTAIN THE TEMPORARY BUILT 
*                BY GSUB AND CONREGI TO CONTAIN THE BRANCH SUBVERB
* 
* 
 DPBRNCH  EGO    4
          NOTE   DPBRNCH
  
*      SUBTRACT C.ZERO FROM EACH WORD TO GET BINARY VALUE 
  
          GEN    SLRBPK,(VREGOF,CVREGA),CVB0,CPZERO 
          GEN    ISUB,(VREGOF,CVREGB),(TREGOF,CONREGD),CVREGA 
          GEN    ISUB,(VREGOF,CVREGC),(TREGP1OF,CONREGD),CVREGA 
  
          IFZ    ((GSCODEOF,CONREGA),EQ,GCOMPARE),DPCOMP
  
          IFTHEN ((GSCODEOF,CONREGI),EQ,GTRUE)
            GOTOCASE  (GSCODEOF,CONREGA)
              CASE   GEQUAL,DPCS3 
              CASE   GGREATER,DPCS1 
              CASE   GLESS,DPCS5
              CASE   GNOTEQ,DPCS4 
              CASE   GNOTGT,DPCS2 
              CASE   GNOTLT,DPCS6 
            ENDCASE 
            ERROR  CONERR2         UNKNOWN CONDITION
          ELSEZ 
            GOTOCASE  (GSCODEOF,CONREGA)
              CASE   GEQUAL,DPCS4 
              CASE   GGREATER,DPCS2 
              CASE   GLESS,DPCS6
              CASE   GNOTEQ,DPCS3 
              CASE   GNOTGT,DPCS1 
              CASE   GNOTLT,DPCS5 
            ENDCASE 
            ERROR  CONERR2
          ENDIFZ
  
*      CASE 1 
  
 DPCS1    LABEL 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    NZ$,CVREGB,LOCALXX 
          MOVEZ  (LOCLAB,LOCXY),LOCXY 
          GEN    ZR$,CVREGC,LOCALXY 
          GEN    LABEL$,LOCALXX 
          GEN    PL$,(TREGOF,CONREGD),((FWA$OF,CONREGI))
          GEN    LABEL$,LOCALXY 
          BRANCH DPRTN
  
*      CASE 2 
  
 DPCS2    LABEL 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    NZ$,CVREGB,LOCALXX 
          GEN    ZR$,CVREGC,((FWA$OF,CONREGI))
          GEN    LABEL$,LOCALXX 
          GEN    NG$,(TREGOF,CONREGD),((FWA$OF,CONREGI))
          BRANCH DPRTN
  
*      CASE 3 
  
 DPCS3    LABEL 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    NZ$,CVREGB,LOCALXX 
          GEN    ZR$,CVREGC,((FWA$OF,CONREGI))
          GEN    LABEL$,LOCALXX 
          BRANCH DPRTN
  
*      CASE 4 
  
 DPCS4    LABEL 
          GEN    NZ$,CVREGB,((FWA$OF,CONREGI))
          GEN    NZ$,CVREGC,((FWA$OF,CONREGI))
          BRANCH DPRTN
  
*      CASE 5 
  
 DPCS5    LABEL 
          GEN    NG$,(TREGOF,CONREGD),((FWA$OF,CONREGI))
          BRANCH DPRTN
  
*      CASE 6 
  
 DPCS6    LABEL 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    NZ$,CVREGB,LOCALXX 
          GEN    ZR$,CVREGC,((FWA$OF,CONREGI))
          GEN    LABEL$,LOCALXX 
          GEN    PL$,(TREGOF,CONREGD),((FWA$OF,CONREGI))
          BRANCH DPRTN
  
*      -COMPARE- VERBS
  
 DPCOMP   LABEL 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    NZ$,CVREGB,LOCALXX 
          MOVEZ  (LOCLAB,LOCXY),LOCXY 
          GEN    ZR$,CVREGC,LOCALXY 
          GEN    LABEL$,LOCALXX 
          GEN    PL$,(TREGOF,CONREGD),((FWA$OF,CONREGI))   GR BRANCH
          GEN    NG$,(TREGOF,CONREGD),((FWA$OF,CONREGE))   LT BRANCH
          GEN    LABEL$,LOCALXY                            EQ FALL THRU 
  
  
 DPRTN    LABEL 
          CALLZ  SUBDNAT     RELEASE THE TEMP DNAT
          RETURN
  
  
 IXVSIX   EJECT 
* 
**        IXVSIX - INDEX NAME VS INDEX NAME 
* 
*                GENERATES: 
*         SAI    B
*         SAJ    C
*         SXK    XI 
*         SXL    XJ 
*         IXM    XK-XL
* 
*         WE THAN CALL SPBRNCH TO BUILD THE PROPER BRANCHING
* 
* 
  
 IXVSIX   EGO    3
  
          NOTE   IXVSIX 
          GEN    SLRBPK,(VREGOF,CVREGB),((FWA$OF,CONREGB))
          GEN    SLRBPK,(VREGOF,CVREGC),((FWA$OF,CONREGC))
          GEN    SXXPB,(VREGOF,CVREGD),CVREGB,CVB0
          GEN    SXXPB,(VREGOF,CVREGE),CVREGC,CVB0
          GEN    ISUB,(VREGOF,CVREGA),CVREGD,CVREGE 
          MOVEZ  CONREGD,CONREGI
          MOVEZ  0,DSPFLG 
          CALLZ  SPBRNCH           BUILD BRANCING 
          RETURN
  
  
 IXVSND   EJECT 
* 
**        IXVSND - INDEX NAME VS OTHER NUMERIC ITEMS
* 
*                WE CALL LOADIX TO LOAD THE ITEM AS A COMP-1
*                AND THEN CALL GSUB TO DO THE SUBTRACT
* 
* 
  
 IXVSND   EGO    3
 IXVSNB   EQU    IXVSND 
 IXVSNF   EQU    IXVSND 
  
          MOVEZ  CONREGC,CONREGK   SAVE THE OTHER GUY 
          MOVEZ  CONREGD,CONREGI   SAVE THE BRANCH FILED
  
          MOVEZ  (EQUALS,CREG11),CONREGT
          CALLZ  ADNAT
          MOVEZ  (EQUALS,CREG11),CONREGC
  
          CALLZ  LOADIX 
  
          MOVEZ  CONREGC,CONREGB
          MOVEZ  CONREGK,CONREGC
          MOVEZ  (EQUALS,CREG12),CONREGT
          CALLZ  ADNAT
          MOVEZ  (EQUALS,CREG12),CONREGD
  
          CALLZ  CGSUB
  
          MOVEZ  (TREGOF,CONREGD),CVREGA
          MOVEZ  0,DSPFLG 
          CALLZ  SPBRNCH
          CALLZ  SUBDNAT
          CALLZ  SUBDNAT
          RETURN
  
  
 NDVSIX   EJECT 
* 
**        NDVSIX - NUMERIC ITEM VS INDEX NAME 
* 
*                WE CALL LOADIX TO LOAD THE INDEX NAEM AS A COMP-1
*                AND THEN CALL CGSUB TO DO THE SUBTRACT 
* 
* 
  
 NDVSIX   EGO    3
 NBVSIX   EQU    NDVSIX 
 NFVSIX   EQU    NDVSIX 
  
          MOVEZ  CONREGB,CONREGK   SAVE NUM ITEM
          MOVEZ  CONREGD,CONREGI   SAVE BRANCH FLD
          MOVEZ  CONREGC,CONREGB   SET UP FOR LOADIX
  
          MOVEZ  (EQUALS,REG11),CONREGT 
          CALLZ  ADNAT
          MOVEZ  (EQUALS,REG11),CONREGC 
  
          CALLZ  LOADIX 
  
          MOVEZ  CONREGK,CONREGB
          MOVEZ  (EQUALS,CREG12),CONREGT
          CALLZ  ADNAT
          MOVEZ  (EQUALS,CREG12),CONREGD
  
          CALLZ  CGSUB
  
          MOVEZ  (TREGOF,CONREGD),CVREGA
          MOVEZ  0,DSPFLG 
          CALLZ  SPBRNCH
          CALLZ  SUBDNAT
          CALLZ  SUBDNAT
          RETURN             SPLIT,YOURE DONE 
  
  
          TITLE  CLASSGEN - CLASS CONDITIONS
  
* 
**        CLASSGEN - CLASS CONDITIONS 
*                IF <NOT> ALPHABETIC
*                   AND 
*                IF <NOT> NUMERIC 
* 
*         CONALPHA - GENERATES CODE FOR THE ALPHABETIC TEST 
*         CONNUMR - GENERATES CODE FOR THE NUMERIC TEST 
* 
  
 CLASSGEN EGO    1
  
  
  
         GOTOCASE  (GSCODEOF,CONREGA) 
          CASE   GALPHA,CONALPHA
          CASE   GNOTALPH,CONALPHA
          CASE   GNUMERIC,CONNUMR 
          CASE   GNOTNUM,CONNUMR
         ENDCASE
* 
          ERROR  CONERR2     UNKNOWN CLASS CONDITION
  
 CONALPHA EJECT 
* 
**        CONALPHA -
*                GENERATES   IF ALPHABETIC AND IF NOT ALPHABETIC
* 
* 
*                FOR FIELD SIZE = 1 CHAR: 
* 
*         SB4    BASE ADDR
*         SB6    BYTE OFFSET
*         RJ     =XC.ALPC1
*+        ZR     B4,TRUE     (FALSE IF A NOT CONDITION) 
* 
* 
* 
*                FOR FIELD SIZE > 1 CHAR: 
* 
*         SB4    BASE ADDR
*         SB5    LENGTH OF FIELD
*         SB6    BYTE OFFSET
*         RJ     =XC.ALPCM
*+        ZR     B4,TRUE     (FALSE IF A NOT CONDITION) 
* 
* 
* 
* 
*                VIRTUAL REGISTERS USED:  
*                            CVREGA,CVREGB,CVREGC 
* 
* 
* 
 CONALPHA EGO    2
* 
*                CHECK FOR IF ALPHA ON A BINARY NUMBER (SPECIAL CASE) 
* 
          IFZ    ((TYPEOF,CONREGB),EQ,COMP1),BINALPH
          IFZ    ((TYPEOF,CONREGB),EQ,COMP2),BINALPH
          IFZ    ((TYPEOF,CONREGB),EQ,COMP4),BINALPH
  
          IFZ    ((BYTLENOF,CONREGB),EQ,(EQUALS,1)),ALPHA1
* 
*         FIELD SIZE > 1
* 
          NOTE   CONALPHA 
          GEN    SBBPK,(VREGOF,CVREGA),CVB0,((FWA$OF,CONREGB)) SB4  FWA 
  
          IFTHEN ((TYPEOF,CONREGB),EQ,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGB),EQ,0)
            MOVEZ  CONREGB,CONREGM
            CALLZ  GETSZVG         GET GROUP SIZE 
*           SETS P1 = V. R. N. OF X-REGISTER WITH LENGTH
            GEN    SBXPB,(VREGOF,CVREGB),P1 
          ENDIFZ
          IFTHEN ((TYPEOF,CONREGB),NE,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGB),EQ,0)
            GEN    SBBPK,(VREGOF,CVREGB),,(BYTLENOF,CONREGB)
          ENDIFZ
  
          IFTHEN  ((GSCODEOF,CONREGB),EQ,0) 
            GEN SBBPK,(VREGOF,CVREGC),,(BCPOF,CONREGB)
         ENDIFZ 
          IFTHEN ((GSCODEOF,CONREGB),NE,0)       VARIABLE SUBSCRIPT 
            MOVEZ  CONREGB,P2 
            CALLZ  SUBREF 
            GEN    SBXPB,(VREGOF,CVREGC),P3 
            GEN    SBXPB,(VREGOF,CVREGB),P4 
          ENDIFZ
          GENOBJ N=C.ALPCM,I=(CVREGA,CVREGB,CVREGC),O=((VREGOF,CVREGA)) 
* 
          CALLZ  GBB         GENERATE B-REG BRANCH
          RETURN
* 
* 
 ALPHA1   EJECT 
* 
**        ALPHA1 - GENERATE CALL TO C.ALPC1 (IF ALPHABETIC FOR 1 CHAR 
*                            FLD) 
* 
 ALPHA1   EGO    2
          NOTE   ALPHA1 
          GEN    SBBPK,(VREGOF,CVREGA),CVB0,((FWA$OF,CONREGB)) SB5  FWA 
          IFTHEN ((GSCODEOF,CONREGB),NE,0)       C.F. VAR SUBSCRIPTING
            MOVEZ  CONREGB,P2 
            CALLZ  SUBREF 
            GEN    SBXPB,(VREGOF,CVREGB),P3 
          ELSEZ 
            GEN    SBBPK,(VREGOF,CVREGB),,(BCPOF,CONREGB)      SB6  BCP 
          ENDIFZ
          GENOBJ N=C.ALPC1,I=(CVREGA,CVREGB),O=((VREGOF,CVREGA))
* 
          CALLZ  GBB         GEN B-REG BARNCH 
          RETURN             SPLIT
* 
* 
 BINALPH  EJECT 
* 
**        BINALPH - HANDLE THE CASE OF IF <NOT> ALPHABETIC WITH A 
*                COMP-1 OR COMP-2 SUBJECT 
*             SAME FOR COMP-4 
* 
*                WE FORCE FALSE ON IF ALPHA 
*         AND 
*                FORCE TRUE ON IF NOT ALPHA 
* 
 BINALPH  EGO    2
  
          CALLZ  IFNOT
  
          IFTHEN (P1,EQ,1)         HAVE A <NOT> 
              CALLZ FFB      FORCE FALSE BRANCH 
          ELSEZ 
              CALLZ FTB      FORCE TRUE BRANCH
          ENDIFZ
  
          RETURN
  
  
 CONNUMR  EJECT 
* 
**        CONNUMR - 
*                GENERATES IF NUMERIC AND IF NOT NUMERIC
*                FOR DISPLAY CODE NUMBERS 
* 
*             CODE GENERATED: 
* 
*         SB4    BYTE OFFSET OF FIELD 
*         SB5    FWA
*         SB6    CHAR LNTH OF FLD 
*         SB7    0 - FIELD UNSIGNED 
*                1 - FIELD SIGNED, TRAILING DIGIT OVERPUNCH 
*                2 - FIELD SIGNED, TRAILING SEP CHAR
*                3 - FIELD SIGNED, LEADING DIGIT OVERPUNCH
*                4 - FIELD SIGNED, LEADING SEP CHAR 
*         RJ     =XC.NUMR    <OR C.NUMRA IF A-OPTION> 
*         EQ     B0,B7,TRUE  (FALSE OF A NOT CONDITION) 
* 
* 
 CONNUMR  EGO    2
  
*      BINARY NUMBERS ARE HANDLED IN BINNUMR
  
          IFZ    ((TYPEOF,CONREGB),EQ,COMP1),BINNUMR
          IFZ    ((TYPEOF,CONREGB),EQ,COMP2),BINNUMR
          IFZ    ((TYPEOF,CONREGB),EQ,COMP4),BINNUMR
  
          NOTE   CONNUMR
          IFTHEN ((GSCODEOF,CONREGB),NE,0)
            MOVEZ  CONREGB,P2 
            CALLZ  SUBREF 
            GEN    SBXPB,(VREGOF,CVREGA),P3 
            GEN    SBXPB,(VREGOF,CVREGC),P4 
          ELSEZ 
            GEN    SBBPK,(VREGOF,CVREGA),,(BCPOF,CONREGB)      SB6  BCP 
            GEN    SBBPK,(VREGOF,CVREGC),,(BYTLENOF,CONREGB)
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGB),CVB0,((FWA$OF,CONREGB)) SB5  FWA 
  
          IFZ    ((SIGNOF,CONREGB),EQ,1),CNUMR1  C.F. SIGN
  
          GEN    SBBPB,(VREGOF,CVREGD),CVB0,CVB0           SB7 B0 
  
          BRANCH CNUMR5 
  
 CNUMR1   LABEL                    SIGNED NUMBERS 
  
          IFZ    ((LDSIGNOF,CONREGB),EQ,1),CNUMR3     C.F. LEADING SIGN 
  
          IFTHEN ((SCHAROF,CONREGB),EQ,0) 
              GEN   SBBPB,(VREGOF,CVREGD),CVB1,CVB0        SB7 B1 
          ELSEZ 
              GEN   SBBPB,(VREGOF,CVREGD),CVB1,CVB1        SB7 B1+B1
          ENDIFZ
  
          BRANCH CNUMR5 
  
 CNUMR3   LABEL                    LEADING SIGNS
  
          IFTHEN ((SCHAROF,CONREGB),EQ,0) 
              GEN   SBBPK,(VREGOF,CVREGD),CVB0,3           SB7 3
          ELSEZ 
              GEN   SBBPK,(VREGOF,CVREGD),CVB0,4           SB7 4
          ENDIFZ
  
 CNUMR5   LABEL 
  
          MOVEZ  (VREGOF,CVREGE),CVREGE 
          IFTHEN ((CCTBIT,LBZ),NE,0)
          ANDIF  ((TYPEOF,CONREGB),EQ,COMP) 
            GENOBJ N=C.NUMRA,I=(CVREGA,CVREGB,CVREGC,CVREGD),O=CVREGE 
          ELSEZ 
            GENOBJ N=C.NUMR,I=(CVREGA,CVREGB,CVREGC,CVREGD),O=CVREGE
          ENDIFZ
          MOVEZ  (VREFOF,CVREGE),(VREFOF,CVREGA)
* 
          CALLZ  GBB         GEN B-REG BRANCH 
  
          RETURN
* 
* 
* 
 BINNUMR  EJECT 
* 
**        BINNUMR - IF NUMERIC AND IF NOT NUMERIC FOR 
*                COMP-1 AND COMP-2 NUMBERS
* 
* 
*         CODE GENERATED: 
*                FOR COMP-1 NUMBERS-
*         MXI    12 
*         SAJ    X
*         BXK    XI*XJ
*         ZR     XK,TRUE
*         BXL    XI-XJ       TO CHECK FOR -0
*         ZR     XL,TRUE
* 
*                NOTE - THE ABOVE BRANCH SEQUENCE IS ONLY ONE OF TWO
*                SEQUENCES -  SEE NUMCASE FOR EXACT DETAILS 
* 
* 
*                FOR COMP-2 NUMBERS:  
*         EQ     TRUE        (FALSE IF A NOT) 
* 
* 
 BINNUMR  EGO    2
  
          CALLZ  IFNOT
  
*      HANDLE COMP-2 AT COMP2NR 
  
          IFZ    ((TYPEOF,CONREGB),EQ,COMP2),COMP2NR
*      SAME FOR COMP-4
          IFZ    ((TYPEOF,CONREGB),EQ,COMP4),COMP2NR
          NOTE   BINNUMR
  
* 
*                WE NOW GENERATE THE FOLLOWING- 
* 
*         MXI    12 
*         SAJ    X
*         BXK    XI*XJ
* 
  
          GEN    MASK,(VREGOF,CVREGA),12
          IFTHEN ((GSCODEOF,CONREGB),NE,0)       ITEM SUBSCRIPTED 
            MOVEZ  (GSCODEOF,CONREGB),P1
            CALLZ  SUBLOAD
            GEN    SHL,P1,30
            GEN    SXBPK,(VREGOF,CVREGB),,52429       DIVIDE BY 10
            GEN    SXBPK,(VREGOF,CVREGC),,P1
            GEN    IMUL,(VREGOF,CVREGD),CVREGB,CVREGC 
            GEN    SHR,CVREGD,19
            GEN    SLRXPK,(VREGOF,CVREGB),CVREGD,((FWA$OF,CONREGB)) 
          ELSEZ 
            GEN    SLRBPK,(VREGOF,CVREGB),,((FWA$OF,CONREGB)) 
          ENDIFZ
          GEN    LAND,(VREGOF,CVREGC),(VREFOF,CVREGA),(VREFOF,CVREGB) 
  
* 
**               IF THE BRANCH IS FOR A TRUE CONDITION AND THE VERB 
*                IS IF NUMERIC
*                            OR 
*                THE BRANCH IS FALSE AND THE VERB IS IF NOT NUMERIC 
*                            WE GENERATE "CASE A"  ELSE "CASE B"
* 
  
          IFTHEN (P1,EQ,0)         NO <NOT> 
              IFZ   ((GSCODEOF,CONREGC),EQ,GFALSE),NUMCSB    CASE B 
          ELSEZ 
              IFZ   ((GSCODEOF,CONREGC),EQ,GTRUE),NUMCSB     CASE B 
          ENDIFZ             WE GOT CASE A
  
  
 NUMCASE  SPACE  4
  
          GEN    ZR$,(VREFOF,CVREGC),((FWA$OF,CONREGC)) 
          IFZ    ((SIGNOF,CONREGB),EQ,0),RETURN 
          GEN    LXOR,(VREGOF,CVREGD),CVREGA,CVREGC 
          GEN    ZR$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) 
  
          RETURN
  
          SPACE  4
 NUMCSB   LABEL 
  
          IFTHEN ((SIGNOF,CONREGB),EQ,1)
          MOVEZ  (LOCLAB,T1),T1    GET A NEW LOCAL LABEL
  
          GEN    ZR$,(VREFOF,CVREGC),LOCALXX
          GEN    LXOR,(VREGOF,CVREGD),CVREGA,CVREGC 
          GEN    NZ$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) 
          GEN    LABEL$,LOCALXX    DEFINE LOCAL LABEL 
          ELSEZ 
            GEN    NZ$,CVREGC,((FWA$OF,CONREGC))
          ENDIFZ
  
          RETURN
  
 COMP2NR  EJECT 
* 
**        COMP2NR - HANDLE IF <NOT> NUMERIC FOR COMP-2 NUMBERS
*                  HANDLES COMP-4 IN THE SAME WAY 
* 
*                THIS IS A SIMPLE SPECIAL CASE -
*                            IF NUMERIC IS ALWAYS TRUE
*                            IF NOT NUMERIC IS ALWAYS FALSE 
* 
* 
 COMP2NR  EGO    2
  
          IFTHEN (P1,NE,1)         NO <NOT> 
              CALLZ FTB      FORCE TRUE BRANCH
          ELSEZ 
              CALLZ FFB      FORCE FALSE BRANCH 
          ENDIFZ
  
          RETURN
  
  
          TITLE  SIGNGEN - SIGN CONDITIONS
  
 SIGNGEN  EGO    1
  
          GOTOCASE (TYPEOF,CONREGB) 
            CASE    COMP,SIGNDISP  DISPLAY CODE NUMERICS
            CASE    COMP1,SIGNBIN  COMP-1 (BINARY INTEGERS) 
            CASE   COMP4,SIGNCP4  COMP-4 INTEGERS 
            CASE    COMP2,SIGNBIN  COMP-2 (BINARY FLOATING POINT) 
            CASE   DPCOMP2,SIGNBIN
         ENDCASE
  
          ERROR  CONERR3     UNKNOWN DATA TYPE
  
  
 SIGNBIN  EJECT 
  
* 
**        SIGNBIN - GENERATES SIGN TESTS FOR BINARY (COMP-1 AND COMP-2) 
*                            ITEMS
* 
*         GENERATES:  
* 
*                FOR IF POSITIVE OR IF NEGATIVE 
* 
*         SAI    X
*         ZR     XI,FALSE 
* 
*         PL     XI,FALSE    FOR IF NEGATIVE
*           OR
*         NG     XI,FALSE    FOR IF POSITIVE
* 
* 
*                FOR IF NOT POSITIVE OR IF NOT NEGATIVE 
* 
*         SAI    X
*         ZR     XI,TRUE
* 
*         PL     XI,TRUE     FOR IF NOT POSITIVE
*           OR
*         NG     XI,TRUE     FOR IF NOT NEGATIVE
* 
* 
  
 SIGNBIN  EGO    2
  
          CALLZ  IFNOT       HAVE WE A <NOT> SOMETHING
  
          NOTE   SIGNBIN
          IFZ    ((LEVELOF,CONREGB),EQ,TEMPLEVL),SBIN2
          IFTHEN ((GSCODEOF,CONREGB),NE,0)
            PUSH   P1 
            MOVEZ  (GSCODEOF,CONREGB),P1
            CALLZ  SUBLOAD
            GEN    SHL,P1,30
            GEN    SXBPK,(VREGOF,CVREGA),,52429 
            GEN    SXXPB,(VREGOF,CVREGB),P1 
            GEN    IMUL,(VREGOF,CVREGC),CVREGA,CVREGB 
            GEN    SHR,CVREGC,19   DIVIDE BY 10 
            GEN    SLRXPK,(VREGOF,CVREGA),CVREGC,((FWA$OF,CONREGB)) 
            POP    P1 
          ELSEZ 
            GEN    SLRBPK,(VREGOF,CVREGA),,((FWA$OF,CONREGB)) 
          ENDIFZ
          BRANCH BINTRU 
  
 SBIN2    LABEL 
          MOVEZ  (TREGOF,CONREGB),CVREGA
          BRANCH BINTRU 
  
 BINTRU   EJECT 
 BINTRU   LABEL 
          IFZ    ((GSCODEOF,CONREGC),EQ,GFALSE),BINFLSE   FALSE NODES 
* 
*                WE NOW HANDLE ALL FOUR CASES (POS, NEG, NOT POS, 
*                            NOT NEG) WHERE THE BRANCH IS TAKEN ON
*                            A TRUE CONDITION 
* 
          IFZ    (P1,EQ,1),TRUNOT     GOT A <NOT> 
          MOVEZ  (LOCLAB,T1),T1    GET A LOCAL LABEL
  
          GEN    ZR$,(VREFOF,CVREGA),LOCALXX
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   PL$,(VREFOF,CVREGA),((FWA$OF,CONREGC))
          ELSEZ 
              GEN   NG$,(VREFOF,CVREGA),((FWA$OF,CONREGC))
          ENDIFZ
  
          GEN    LABEL$,LOCALXX    DEFINE LOCALXX 
          RETURN             XIT
  
* 
* 
  
 TRUNOT   LABEL 
  
          GEN    ZR$,(VREFOF,CVREGA),((FWA$OF,CONREGC)) 
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GNOTPOS)
              GEN   NG$,(VREFOF,CVREGA),((FWA$OF,CONREGC))
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGA),((FWA$OF,CONREGC))
          ENDIFZ
  
          RETURN
          EJECT 
* 
**        GENERATES SIGN TEST FOR COMP-4 ITEM 
* 
**
 SIGNCP4  EGO    2
* 
          CALLZ  IFNOT                           HAVE WE <NOT> SOMETHING
          NOTE   SIGNCP4
          CALLZ  LOADC4 
          BRANCH BINTRU 
 BINFLSE  EJECT 
  
* 
*                ALL FALSE BRANCH CODE IS GENERATED HERE
* 
  
 BINFLSE  LABEL 
  
          IFZ    (P1,EQ,1),FLSNOT     GOT A <NOT> 
  
          GEN    ZR$,(VREFOF,CVREGA),((FWA$OF,CONREGC)) 
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   NG$,(VREFOF,CVREGA),((FWA$OF,CONREGC))
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGA),((FWA$OF,CONREGC))
          ENDIFZ
  
          RETURN
  
 FLSNOT   LABEL 
  
          MOVEZ  (LOCLAB,T1),T1 
          GEN    ZR$,(VREFOF,CVREGA),LOCALXX
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GNOTPOS)
              GEN   PL$,(VREFOF,CVREGA),((FWA$OF,CONREGC))
          ELSEZ 
              GEN   NG$,(VREFOF,CVREGA),((FWA$OF,CONREGC))
          ENDIFZ
  
          GEN    LABEL$,LOCALXX 
          RETURN             SPLIT
  
  
 SIGNDISP EJECT 
  
* 
**        SIGNDISP - GENERATE SIGN TESTS FOR DISPLAY CODE NUMBERS 
* 
*                FOR SIGN CHARACTER (EITHER LEADING OR TRAILING)
*                OVERPUNCH, WE FIRST EXAMINE THE SIGN CHARACTER,
*                IF IT IS NON-ZERO, WE THEN ALSO KNOW THE SIGN OF THE 
*                ITEM.  IF IT IS ZERO, WE THEN CHECK THE REST OF THE
*                NUMBER FOR NON-ZERO. 
* 
*                ZERO IS ALWAYS FALSE FOR IF POSITIVE AND IF NEGATIVE,
*                AND ALWAYS TRUE FOR IF NOT POSITIVE AND IF NOT NEGATIVE
* 
*                FOR SIGN IS SEPERATE CHARACTER, WE CALL GMOVE TO LOAD
*                THE NUMBER INTO REGISTERS IN NINES COMP FORM, AND
*                MAKE THE TEST DIRECTLY.
* 
* 
  
 SIGNDISP EGO    2
  
          IFZ    ((LEVELOF,CONREGB),EQ,TEMPLEVL),SIGNTMP
          IFZ    ((SCHAROF,CONREGB),NE,0),SEPDISP     SEP CHAR
          IFZ    ((GSCODEOF,CONREGB),NE,0),SEPDISP    VAR SUBSCR ALSO 
  
          CALLZ  IFNOT
          IFZ    ((LDSIGNOF,CONREGB),NE,0),LEADOV     LEADING OVERPUNCH 
  
* 
**               WE HANDLE TRAILING DIGIT OVERPUNCH (DEFAULT CASE) AS 
*                TWO CASES: 
*                            CASE A - IFPOS AND IF NEG
*                            CASE B - IF NOT POS AND IF NOT NEG 
**
*                INITIALIZATION FOR BOTH CASES IS DONE HERE;  WE COMPUTE
*                SHIFT VALUES, ETC: 
* 
*                            SBCP - SIGNS BCP = REMZ (BCP+LNTH)/10
* 
*                            LSC - LEFT SHIFT COUNT - REQUIRED TO 
*                            RIGHT JUSTIFY SIGN - STORED IN T3
*                                  LSC = SBCP*6 
* 
*                            NOC - NUMBER OF OTHER CHARS IN LAST WORD 
*                            (EXCLUDES SIGN CHAR) - STORED IN T4 (*6) 
*                                  IF (SBCP-LNTH)\0; NOC = LNTH-1 
*                                  ELSE  NOC = SBCP.
* 
*                            LLW - LENGTH LAST WORD (IN CHARS) - STORED 
*                            IN T5
*                                  LLW = NOC + 1
* 
*                            THE ITEM LENGTH IN WORDS IS STORED IN P2 
* 
* 
* 
          ADDZ   (BCPOF,CONREGB),(BYTLENOF,CONREGB),T9
          MOVEZ  1,P2              SET DEFAULT ITEM LENGTH
          MOVEZ  T9,T2       SET DEFAULT SBCP 
  
          IFZ    (T9,LE,10),ONEWD 
  
          IFTHEN (T9,LE,20) 
              MOVEZ 2,P2           SET 2 WORDS
          ELSEZ 
              MOVEZ 3,P2           SET 3 WORDS
          ENDIFZ
  
          REMZ   T9,10,T2    COMPUTE SBCP 
  
 ONEWD    LABEL 
  
          MULTZ  T2,6,LSC          LSC - LEFT SHIFT COUNT 
          SUBZ   T2,(BYTLENOF,CONREGB),T4 
  
          IFTHEN (T4,GE,0)         COMPUTE NOC
              SUBZ  (BYTLENOF,CONREGB),1,T4 
          ELSEZ 
              SUBZ  T2,1,T4 
          ENDIFZ
          IFZ    (LSC,NE,0),SKIP1 
          IFTHEN ((BYTLENOF,CONREGB),LT,10) 
              SUBZ  (BYTLENOF,CONREGB),1,T4 
          ELSEZ 
              MOVEZ 9,T4
          ENDIFZ
 SKIP1    LABEL 
  
          ADDZ   T4,1,T5
          SUBZ   P2,1,T6           BUILD WORD OFFSET
          MULTZ  NOC,6,NOC         NOC = T4 
          MULTZ  LLW,6,LLW         LLW = T5 
  
          IFZ    (P1,EQ,1),TON     TRAILING OVERPUNCH - <NOT> VERB
  
  
 TOP      EJECT 
* 
**        TOP    TRAILING (UNITS) DIGIT OVERPUNCH 
*                            WITH 
*                IF POSITIVE AND IF NEGATIVE VERBS
* 
* 
*                THE CODE GENERATED IS ROUGHLY THE SAME FOR 1, 2
*                AND 3 WORD CASES.
* 
*         CODE GENERATED: 
*         SAI    X+2         (LWA OF ITEM)
*         MXJ    54 
*         LXI    LSC         (LEFT SHIFT COUNT - TO R JUST SIGN)
*         BXK    -XJ*XI      (MASK OFF SIGN CHAR) 
*         SAL    XK+C.STRP   (PICK UP NUM VALUE + SIGN IN BIT 59) 
*         AXL    18 
*         SXM    XL          (CONTAINS THE BINARY VALUE OF THE CHAR)
*         ZR     XM,TAG1
*         PL     XL,TRUE     (NG FOR IF NEG)
*         EQ     FALSE
*TAG1     SAN    C.ZERO      (=10H0000000000) 
*         LXI    60-(LNTH LAST WD)*6   (LEFT JUST WORD) 
*         MXO    (LNTH LAST WD -1)*6   (IGNORE SIGN)
*         BXP    XO*XI
*         BXQ    XO*XN
*         IXQ    XQ-XP
* * * * *                    FOR 1 WORD ITEMS ONLY: 
*         ZR     XQ,FALSE 
*         PL     XL,TRUE     (NG FOR IF NEG)
* * * * 
* 
* * * * *                    FOR MULTI-WORD ITEMS:  
*         ZR     XQ,TAG2
*         PL     XL,TRUE     (NG FOR IF NEG)
*         EQ     FALSE
*TAG2     BSS    0
* 
***                          3 WORD ITEMS AND 2 WORD ITEMS WITH A FULL
*                            SECOND WORD USE THE FOLLOWING CODE:  
*         SAR    AI-B1
*         IXS    XR-XN
*         ZR     XS,TAG3
*         PL     XL,TRUE     (NG FOR IF NEG)
*         EQ     FALSE
* 
*                            MULTI-WORD ITEMS MAY USE THIS CODE:  
* 
* TAG3    SAT    AR-B1
*         MXU    (BCP-1)*6
*         BXV    -XU*XT 
*         BXW    -XU*XN 
*         BXW    XW-XV
*         ZR     XW,FALSE 
*         PL     XL,TRUE     (NG FOR IF NEG)
* 
  
 TOP      EGO    3
  
          IFZ    ((BYTLENOF,CONREGB),EQ,1),SCF   SINGLE CHAR FIELDS 
          NOTE   TOP
  
*      AT THIS POINT WE ARE LEFT WITH ONLY 2+ CHAR FLDS, SINCE
*      SINGLE CHAR FLDS HAVE GONE TO SCF
  
          GEN    SLRBPK,(VREGOF,CVREGA),CVB0,FWAPLUS
          GEN    MASK,(VREGOF,CVREGB),54
          IFTHEN (LSC,LT,60)                     SKIP SHIFTS OF 60
              GEN   SHL,(VREFOF,CVREGA),LSC 
          ENDIFZ
          GEN    LIMP,(VREGOF,CVREGC),CVREGA,CVREGB 
          GEN    SLRXPK,(VREGOF,CVREGB),CVREGC,CPSTRP 
          GEN    SHR,CVREGB,18
          GEN    SXXPB,(VREGOF,CVREGF),CVREGB 
          MOVEZ  (LOCLAB,LOCXY),LOCXY 
  
          CALLZ  SGNJMPS     GENERATE JUMPS 
  
          GEN    LABEL$,LOCALXX    DEFINE TAG1
          GEN    SLRBPK,(VREGOF,CVREGC),CVB0,CPZERO 
          IFZ    (NOC,EQ,0),TO6                  NO OTHER CHARS IN WORD 
          SUBZ   60,LLW,LLW 
          IFTHEN (LLW,NE,0) 
              GEN   SHL,(VREFOF,CVREGA),LLW 
          ENDIFZ
          GEN    MASK,(VREGOF,CVREGD),NOC 
          GEN    LAND,(VREGOF,CVREGE),(VREFOF,CVREGD),(VREFOF,CVREGC) 
          GEN    LAND,(VREGOF,CVREGF),(VREFOF,CVREGD),(VREFOF,CVREGA) 
          GEN    ISUB,(VREGOF,CVREGF),CVREGF,CVREGE 
  
          IFZ    (P2,EQ,1),TO10A
  
          CALLZ  SGNJMPS
  
 TO6      LABEL 
  
          IFTHEN (P2,EQ,2)
              IFZ   ((BCPOF,CONREGB),NE,0),TO10 
          ENDIFZ
  
*      3 WORD ITEMS + 2 WORD ITEMS W/BCP = 0
  
  
          IFTHEN (T4,NE,0)
              GEN   LABEL$,LOCALXX
          ENDIFZ
  
          GEN    SLRAMB,(VREGOF,CVREGD),CVREGA,CVB1 
          GEN    ISUB,(VREGOF,CVREGF),CVREGC,CVREGD 
  
          IFZ    (P2,EQ,3),TO8
  
          IFZ    ((GSCODEOF,CONREGC),EQ,GFALSE),TO7 
  
          GEN    ZR$,(VREFOF,CVREGF),LOCALXY               ZR  XS,FALSE 
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   PL$,(VREFOF,CVREGB),((FWA$OF,CONREGC)) PL  XL,TRUE
          ELSEZ 
              GEN   NG$,(VREFOF,CVREGB),((FWA$OF,CONREGC)) NG  XL,TRUE
          ENDIFZ
          BRANCH TO20 
  
 TO7      LABEL 
  
          GEN    ZR$,(VREFOF,CVREGF),((FWA$OF,CONREGC))    ZR  XS,FALSE 
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   NG$,(VREFOF,CVREGB),((FWA$OF,CONREGC)) NG  XL,FALSE 
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGB),((FWA$OF,CONREGC)) PL  XL,FALSE 
          ENDIFZ
          BRANCH TO20 
  
 TO8      LABEL 
  
          CALLZ  SGNJMPS
  
 TO10     LABEL 
  
          GEN    LABEL$,LOCALXX 
          IFTHEN (P2,EQ,2)
              GEN   SLRAMB,(VREGOF,CVREGE),(VREFOF,CVREGA),CVB1 
          ELSEZ 
            GEN    SLRAMB,(VREGOF,CVREGE),CVREGD,CVB1 
          ENDIFZ
          MULTZ  (BCPOF,CONREGB),6,T3            T3=BCP*6 
          GEN    MASK,(VREGOF,CVREGD),T3
          GEN    LIMP,(VREGOF,CVREGA),CVREGE,CVREGD 
          GEN    LIMP,(VREGOF,CVREGF),CVREGC,CVREGD 
          GEN    ISUB,(VREGOF,CVREGF),CVREGF,CVREGA 
  
 TO10A    LABEL 
  
          IFZ    ((GSCODEOF,CONREGC),EQ,GFALSE),TO11
  
          GEN    ZR$,(VREFOF,CVREGF),LOCALXY
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   PL$,(VREFOF,CVREGB),((FWA$OF,CONREGC))
          ELSEZ 
              GEN   NG$,(VREFOF,CVREGB),((FWA$OF,CONREGC))
          ENDIFZ
          BRANCH TO20 
  
 TO11     LABEL 
  
          GEN    ZR$,(VREFOF,CVREGF),((FWA$OF,CONREGC)) 
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   NG$,(VREFOF,CVREGB),((FWA$OF,CONREGC))
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGB),((FWA$OF,CONREGC))
          ENDIFZ
  
 TO20     LABEL 
  
          GEN    LABEL$,LOCALXY    DEFINE FINAL LABEL 
  
          RETURN             SPLIT
  
  
 TON      EJECT 
* 
**        TON    TRAILING OVERPUNCH - <NOT> VERB
* 
*                TRAILING (UNITS) DIGIT OVERPUNCH 
*                            WITH 
*                IF NOT POSITIVE AND IF NOT NEGATIVE
* 
* 
*                THE CODE GENERATED IS ROUGHLY THE SAME FOR 1,2 AND 
*                3 WORD CASES.
* 
*         GENERATES:  
*         SAI    LWA ITEM 
*         MXJ    54 
*         LXI    LSC               (LEFT SHIFT COUNT - TO R JUST SIGN)
*         BXK    -XJ*XI 
*         SAL    XK+C.STRP
*         NG     XL,TRUE           (PL FOR IF NOT NEG)
*         AXL    18 
*         SXM    XL 
*         ZR     XM,TAG1
*         EQ     FALSE
*TAG1     SAN    C.ZERO 
*         LXI    60-(LNTH LAST WD)*6
*         MXO    (LNTH LAST WD -1)*6
*         BXP    XO*XI
*         BXQ    XO*XN
*         BXQ    XQ-XP
*         NZ     XQ,FALSE 
*         SAR    AI-B1             3 WORDS ONLY 
*         IXS    XR-XN             3 WORDS ONLY 
*         NZ     XS,FALSE          3 WORDS ONLY 
*         SAT    AR-B1
*         MXU    BCP*6
*         BXV    -XU*XT 
*         BXW    -XU*XN 
*         BXW    XW-XV
*         ZR     XW,TRUE
* 
* 
 TON      EGO    3
  
* 
*                            SINGLE WORD ITEMS ARE HANDLED AT SCFN
* 
          IFZ    ((BYTLENOF,CONREGB),EQ,1),SCFN  SINGLE CHAR FLD - <NOT>
          NOTE   TON
  
          GEN    SLRBPK,(VREGOF,CVREGA),CVB0,FWAPLUS
          GEN    MASK,(VREGOF,CVREGB),54
          IFTHEN (LSC,LT,60)           SKIP SHIFTS OF 60
              GEN   SHL,(VREFOF,CVREGA),LSC 
          ENDIFZ
          GEN    LIMP,(VREGOF,CVREGC),CVREGA,CVREGB 
          GEN    SLRXPK,(VREGOF,CVREGD),CVREGC,CPSTRP 
  
          IFZ    ((GSCODEOF,CONREGC),EQ,GFALSE),TON1
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GNOTPOS)
              GEN   NG$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) NG  XL,TRUE
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) PL  XL,TRUE
          ENDIFZ
          BRANCH TON2 
  
 TON1     LABEL 
  
          MOVEZ  (LOCLAB,LOCXY),LOCXY 
          IFTHEN ((GSCODEOF,CONREGA),EQ,GNOTPOS)
              GEN   NG$,(VREFOF,CVREGD),LOCALXY 
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGD),LOCALXY 
          ENDIFZ
  
 TON2     LABEL 
  
          GEN    SHR,CVREGD,18
          GEN    SXXPB,(VREGOF,CVREGB),CVREGD 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    ZR$,(VREFOF,CVREGB),LOCALXX
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              MOVEZ (LOCLAB,T10),T10
              GEN   EQ$,CVB0,CVB0,LOCALXY 
          ELSEZ 
              GEN   EQ$,CVB0,CVB0,((FWA$OF,CONREGC))
          ENDIFZ
          GEN    LABEL$,LOCALXX 
          GEN    SLRBPK,(VREGOF,CVREGB),CVB0,CPZERO 
  
          IFZ    (NOC,EQ,0),TON4                 IF NOTHING ELSE IN WORD
  
          SUBZ   60,LLW,LLW 
          GEN    SHL,(VREFOF,CVREGA),LLW
          GEN    MASK,(VREGOF,CVREGC),NOC 
          GEN    LAND,(VREGOF,CVREGD),(VREFOF,CVREGC),(VREFOF,CVREGA) 
          GEN    LAND,(VREGOF,CVREGE),(VREFOF,CVREGC),(VREFOF,CVREGB) 
          GEN    ISUB,(VREGOF,CVREGE),CVREGE,CVREGD 
  
          IFZ    (P2,GT,1),TON3 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   ZR$,(VREFOF,CVREGE),((FWA$OF,CONREGC))
          ELSEZ 
              GEN   NZ$,(VREFOF,CVREGE),((FWA$OF,CONREGC))
          ENDIFZ
          BRANCH TON20
  
 TON3     LABEL 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)   GEN       NZ  XQ,FALSE 
              GEN   NZ$,(VREFOF,CVREGE),LOCALXY 
          ELSEZ 
              GEN   NZ$,(VREFOF,CVREGE),((FWA$OF,CONREGC))
          ENDIFZ
  
 TON4     LABEL 
  
          IFTHEN (P2,EQ,2)
              IFZ   ((BCPOF,CONREGB),NE,0),TON6 
          ENDIFZ
  
          GEN    SLRAMB,(VREGOF,CVREGC),CVREGA,CVB1 
          GEN    ISUB,(VREGOF,CVREGD),CVREGB,CVREGC 
  
          IFZ    (P2,EQ,3),TON5 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   ZR$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) ZR  XS,TRUE
          ELSEZ 
              GEN   NZ$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) NZ  XS,FALSE 
          ENDIFZ
          BRANCH TON20
  
 TON5     LABEL 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)   GEN       NZ  XS,FALSE 
              GEN   NZ$,(VREFOF,CVREGD),LOCALXY 
          ELSEZ 
              GEN   NZ$,(VREFOF,CVREGD),((FWA$OF,CONREGC))
          ENDIFZ
  
 TON6     LABEL 
  
          IFTHEN (P2,EQ,2)
            GEN    SLRAMB,(VREGOF,CVREGD),CVREGA,CVB1 
          ELSEZ 
            GEN    SLRAMB,(VREGOF,CVREGD),CVREGC,CVB1 
          ENDIFZ
  
          MULTZ  (BCPOF,CONREGB),6,T4 
          GEN    MASK,(VREGOF,CVREGC),T4
          GEN    LIMP,(VREGOF,CVREGE),CVREGD,CVREGC 
          GEN    LIMP,(VREGOF,CVREGF),CVREGB,CVREGC 
          GEN    ISUB,(VREGOF,CVREGF),CVREGF,CVREGE 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   ZR$,(VREFOF,CVREGF),((FWA$OF,CONREGC)) ZR  XW,TRUE
          ELSEZ 
              GEN   NZ$,(VREFOF,CVREGF),((FWA$OF,CONREGC)) NZ  XW,FALSE 
          ENDIFZ
  
 TON20    LABEL 
  
          GEN    LABEL$,LOCALXY    DEFINE THE FINAL LOCAL LABEL 
  
          RETURN                   SPLIT
  
  
 LEADOV   EJECT 
* 
*         LEADOV HANDLES LEADING DIGIT OVERPUNCH
* 
*                WE HANDLE LEADING DIGIT OVERPUNCH AS TWO CASES:  
*                            CASE A - IF POS + IF NEG 
*                            CASE B - IF NOT POS + IF NOT NEG 
* 
* 
*                INITIALIZATION FOR BOTH CASES IS DONE HERE; WE COMPUTE 
*                SHIFT VALUES, ETC: 
* 
*                            LSC - LEFT SHIFT COUNT, REQUIRED TO PLACE
*                            THE SIGN IN BITS 0-5  - STORED IN T3 
*                                  LSC = (BCP+1)*6
* 
*                            NOC - NUMBER OTHER CHARS IN WORD (CHAR COUNT 
*                            OF 1ST WORD, NOT INCL. SIGN)  -STORED IN 
*                            T4 (MULT BY 6) 
*                                  NOC = 9 - BCP
* 
*                            RCI - REMAINING CHARS IN ITEM -
*                            STORED IN T5 (MULT BY 6) 
*                                  RCI = LNTH - (NOC+1) 
*                                  IF RCI > 10; RCI = RCI - 10
* 
*                            ITEM LENGTH IN WORDS IS STORED IN P2.
* 
* 
  
 LEADOV   EGO    2
  
          ADDZ   (BCPOF,CONREGB),(BYTLENOF,CONREGB),T9
  
          MOVEZ  1,P2              SET DEFAULT LENGTH 
  
          IFZ    (T9,LE,10),LEADOV1 
  
          IFTHEN (T9,LE,20) 
              MOVEZ 2,P2           SET 2 WORDS
          ELSEZ 
              MOVEZ 3,P2           SET 3 WORDS
          ENDIFZ
  
 LEADOV1  LABEL 
  
          ADDZ   (BCPOF,CONREGB),1,T3 
          MULTZ  T3,6,T3
  
          SUBZ   9,(BCPOF,CONREGB),T4 
  
          ADDZ   T4,1,T5
          SUBZ   (BYTLENOF,CONREGB),T5,T5 
  
          MULTZ  NOC,6,NOC                       NOC = T4 
          MULTZ  RCI,6,RCI                       RCI = T5 
          SUBZ   P2,1,T6           COMPUTE WORD OFFSET
  
*      BRANCH TO PROPER CASE
  
          IFZ    (P1,EQ,1),LON     CASE B - LEADING OVERPUNCH <NOT> VERB
  
  
 LOP      EJECT 
* 
**        LOP    LEADING OVERPUNCH
*                            FOR
*                IF POSITIVE AND IF NEGATIVE
* 
* 
*                THE CODE GENERATED IS ROUGHTLY THE SAME FOR
*                1, 2, AND 3 WORD ITEMS 
* 
*         GENERATES:  
*         SAI    X
*         MXJ    54 
*         LXI    LSC         (RIGHT JUST SIGN CHAR) 
*         BXK    -XJ*XI 
*         SAL    XK+C.STRP
*         AXL    18 
*         SXM    XL 
*         ZR     XM,TAG1
*         PL     XL,TRUE     (NG FOR IF NEG)
*         EQ     FALSE
*TAG1     SAN    C.ZERO 
*         MXO    NOC*6       NR OTHER CHARS IN WORD 
*         BXP    XO*XI
*         BXQ    XO*XN
*         IXQ    XQ-XP
*         ZR     XQ,TAG2
*         PL     XL,TRUE     (NG FOR IF NEG)
*         EQ     FALSE
*TAG2     SAR    AI+B1       (THIS CODE IS USED FOR 3 WORD ITEMS
*         IXS    XR-XN
*         ZR     XS,TAG3
*         PL     XL,TRUE     (NG FOR IF NEG)
*         EQ     FALSE
*TAG3     SAT    AR+B1       (MOST 2 WORD ITEMS COME HERE)
*         MXU    RCI*6
*         BXV    XU*XT
*         BXW    XU*XN
*         IXW    XW-XV
*         ZR     XW,FALSE 
*         NG     XL,FALSE    (PL FOR IF NEG)
* 
* 
  
 LOP      EGO    3
  
*                SINGLE CHAR ITEMS ARE HANDLED AT SCF 
* 
          IFZ    ((BYTLENOF,CONREGB),EQ,1),SCF   SINGLE CHAR FLD
          NOTE   LOP
  
          GEN    SLRBPK,(VREGOF,CVREGA),CVB0,((FWA$OF,CONREGB)) 
          GEN    MASK,(VREGOF,CVREGC),54
          IFTHEN (LSC,LT,60)           DONT GEN SHIFTS OF 60
              GEN   SHL,(VREFOF,CVREGA),LSC 
          ENDIFZ
          GEN    LIMP,(VREGOF,CVREGD),CVREGA,CVREGC 
          GEN    SLRXPK,(VREGOF,CVREGB),CVREGD,CPSTRP 
          GEN    SHR,CVREGB,18
          GEN    SXXPB,(VREGOF,CVREGF),CVREGB 
          MOVEZ  (LOCLAB,LOCXY),LOCXY 
  
          CALLZ  SGNJMPS           GEN THE JUMPS
  
          GEN    LABEL$,LOCALXX 
          GEN    SLRBPK,(VREGOF,CVREGC),CVB0,CPZERO 
  
          IFZ    (NOC,EQ,0),LOP1                 NO OTHER CHARS IN WORD 
  
          GEN    MASK,(VREGOF,CVREGD),NOC 
          GEN    LAND,(VREGOF,CVREGE),(VREFOF,CVREGD),(VREFOF,CVREGA) 
          GEN    LAND,(VREGOF,CVREGG),CVREGD,CVREGC 
          GEN    ISUB,(VREGOF,CVREGF),CVREGG,CVREGE 
  
          IFZ    (P2,EQ,1),LOP15
  
          CALLZ  SGNJMPS
          GEN    LABEL$,LOCALXX 
  
 LOP1     LABEL 
  
*      FOR 2 WORD ITEMS WITH < 10 CHARS IN THE SECOND WORD, WE GO TO
*      LOP2; FOR 3 WORD ITEMS AND ITEMS WITH FULL SECOND WORDS, WE STAY 
*      HERE.
  
          IFTHEN (P2,EQ,2)         2 WORD ITEMS 
              IFZ  (RCI,LT,60),LOP2              JUMP IF WORD NOT FULL
          ENDIFZ
  
          GEN    SLRAPB,(VREGOF,CVREGD),CVREGA,CVB1 
          GEN    ISUB,(VREGOF,CVREGF),CVREGD,CVREGC 
  
          IFZ    (P2,EQ,2),LOP15
  
          CALLZ  SGNJMPS
          GEN    LABEL$,LOCALXX 
  
 LOP2     LABEL 
  
          IFTHEN (P2,EQ,2)
            GEN    SLRAPB,(VREGOF,CVREGE),CVREGA,CVB1 
          ELSEZ 
            GEN    SLRAPB,(VREGOF,CVREGE),CVREGD,CVB1 
          ENDIFZ
  
          GEN    MASK,(VREGOF,CVREGD),RCI 
          GEN    LAND,(VREGOF,CVREGA),(VREFOF,CVREGD),(VREFOF,CVREGE) 
          GEN    LAND,(VREGOF,CVREGF),(VREFOF,CVREGD),(VREFOF,CVREGC) 
          GEN    ISUB,(VREGOF,CVREGF),CVREGF,CVREGA 
  
 LOP15    LABEL 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   ZR$,(VREFOF,CVREGF),LOCALXY            ZR  XW,FALSE 
          ELSEZ 
              GEN   ZR$,(VREFOF,CVREGF),((FWA$OF,CONREGC)) ZR  XW,FALSE 
          ENDIFZ
  
          IFZ    ((GSCODEOF,CONREGC),EQ,GFALSE),LOP16 
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   PL$,(VREFOF,CVREGB),((FWA$OF,CONREGC)) PL  XL,TRUE
          ELSEZ 
              GEN   NG$,(VREFOF,CVREGB),((FWA$OF,CONREGC)) NG  XL,TRUE
          ENDIFZ
          BRANCH LOP20
  
 LOP16    LABEL 
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   NG$,(VREFOF,CVREGB),((FWA$OF,CONREGC)) NG  XL,FALSE 
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGB),((FWA$OF,CONREGC)) PL  XL,FALSE 
          ENDIFZ
  
 LOP20    LABEL 
  
          GEN    LABEL$,LOCALXY    DEFINE FINAL TAG 
  
          RETURN             SPLIT
  
  
 LON      EJECT 
* 
**        LON -  LEADING (DIGIT) OVERPUNCH - <NOT> VERBS
*                            FOR
*                IF NOT POSITIVE AND IF NOT NEGATIVE
* 
* 
*                THE CODE GENERATED IS ROUGHLY THE SAME FOR 
*                1, 2, AND 3 WORD ITEMS (SEE LEADOV FOR ABBRIVIATIONS)
* 
*         GENERATES:  
*         SAI    X
*         MXJ    54 
*         LXI    LSC               (TO RIGHT JUST THE SIGN CHAR)
*         BXK    -XJ*XI 
*         SAL    XK+C.STRP
*         NG     XL,TRUE           (PL FOR IF NOT NEG)
*         AXL    18 
*         SXM    XL          (ANY NON-ZERO FROM HERE ON DOWN IS 
*                                  FALSE) 
*         ZR     XM,TAG1
*         EQ     FALSE
*TAG1     SAN    C.ZERO 
*         MXO    NOC               (NR OTHER CHARS)*6 
*         BXP    XO*XI
*         BXQ    XO*XN
*         IXQ    XQ-XP
*         NZ     XQ,FALSE 
*         SAR    AI+B1
*         IXS    XR-XN
*         NZ     XS,FALSE 
*         SAT    AR+B1
*         MXU    RCI               (REMAIN CHARS IN WD) 
*         BXV    XU*XT
*         BXW    XU*XN
*         BXW    XW-XV
*         IXW    XW-XV
* 
* 
*                            WE HANDLE 1 CHAR ITEMS AT SCFN 
* 
 LON      EGO    3
  
          IFZ    ((BYTLENOF,CONREGC),EQ,1),SCFN  SINGLE CHAR FLD - NOT
          NOTE   LON
  
          GEN    SLRBPK,(VREGOF,CVREGA),CVB0,((FWA$OF,CONREGB)) 
          GEN    MASK,(VREGOF,CVREGB),54
          IFTHEN (LSC,LT,60)
              GEN   SHL,(VREFOF,CVREGA),LSC 
          ENDIFZ
          GEN    LIMP,(VREGOF,CVREGC),(VREFOF,CVREGB),(VREFOF,CVREGA) 
          GEN    SLRXPK,(VREGOF,CVREGD),CVREGC,CPSTRP 
          MOVEZ  (LOCLAB,T1),T1 
  
          IFZ    ((GSCODEOF,CONREGA),EQ,GNOTNEG),LON1 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   NG$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) NG  XL,TRUE
          ELSEZ 
              GEN   NG$,(VREFOF,CVREGD),LOCALXX            NG  XL,TRUE
          ENDIFZ
          BRANCH LON2 
  
 LON1     LABEL 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   PL$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) PL  XL,TRUE
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGD),LOCALXX            PL  XL,TRUE
          ENDIFZ
  
 LON2     LABEL 
  
          GEN    SHR,CVREGD,18
          GEN    SXXPB,(VREGOF,CVREGB),CVREGD 
          MOVEZ  (LOCLAB,LOCXY),LOCXY 
          GEN    ZR$,(VREFOF,CVREGB),LOCALXY
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   EQ$,CVB0,CVB0,LOCALXX                  EQ  FALSE
          ELSEZ 
              GEN   EQ$,CVB0,CVB0,((FWA$OF,CONREGC))       EQ  FALSE
          ENDIFZ
  
          GEN    LABEL$,LOCALXY 
          GEN    SLRBPK,(VREGOF,CVREGB),CVB0,CPZERO 
  
          IFZ    (NOC,EQ,0),LON3       WORD ONLY CONTAINS SIGN CHAR 
  
          GEN    MASK,(VREGOF,CVREGC),NOC 
          GEN    LAND,(VREGOF,CVREGD),(VREFOF,CVREGC),(VREFOF,CVREGA) 
          GEN    LAND,(VREGOF,CVREGF),(VREFOF,CVREGC),(VREFOF,CVREGB) 
          GEN    ISUB,(VREGOF,CVREGF),CVREGF,CVREGD 
  
          IFZ    (P2,EQ,1),LON10       ONE WORD FIELD 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   NZ$,(VREFOF,CVREGF),LOCALXX            NZ  XQ,FALSE 
          ELSEZ 
              GEN   NZ$,(VREFOF,CVREGF),((FWA$OF,CONREGC)) NZ  XQ,FALSE 
          ENDIFZ
  
 LON3     LABEL 
  
          IFTHEN (P2,EQ,2)
              IFZ   (RCI,LT,60),LON4                       NOT A FULL WORD
          ENDIFZ
  
          GEN    SLRAPB,(VREGOF,CVREGC),CVREGA,CVB1 
          GEN    ISUB,(VREGOF,CVREGF),CVREGC,CVREGB 
  
          IFZ    (P2,EQ,2),LON10
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   NZ$,(VREFOF,CVREGF),LOCALXX 
          ELSEZ 
              GEN   NZ$,(VREFOF,CVREGF),((FWA$OF,CONREGC))
          ENDIFZ
  
 LON4     LABEL 
  
          IFTHEN (P2,EQ,2)
            GEN    SLRAPB,(VREGOF,CVREGD),CVREGA,CVB1 
          ELSEZ 
            GEN    SLRAPB,(VREGOF,CVREGD),CVREGC,CVB1 
          ENDIFZ
  
          GEN    MASK,(VREGOF,CVREGC),RCI 
          GEN    LAND,(VREGOF,CVREGA),(VREFOF,CVREGC),(VREFOF,CVREGD) 
          GEN    LAND,(VREGOF,CVREGF),(VREFOF,CVREGC),(VREFOF,CVREGB) 
          GEN    ISUB,(VREGOF,CVREGF),CVREGF,CVREGA 
  
 LON10    LABEL 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   ZR$,(VREFOF,CVREGF),((FWA$OF,CONREGC))
          ELSEZ 
              GEN   NZ$,(VREFOF,CVREGF),((FWA$OF,CONREGC))
          ENDIFZ
          GEN    LABEL$,LOCALXX    DEFINE FINAL LOCAL LABEL 
          RETURN                   SPLIT
  
  
 SGNJMPS  EJECT 
* 
**        SGNJMPS - BUILD JUMPS FOR DISPLAY CODE SIGN TEST CODE 
*                SEQUENCES
* 
*                THIS ROUTINE IS LOCAL TO SIGNDISP ROUTINES 
* 
* 
*         GENERATES:  
*         ZR     XI,TAGJ
*         PL     XL,TRUE     (NG FOR IF NEGATIVE) 
*         EQ     FALSE
* 
* 
*         INPUT:  
*         CVREGF - X-REG TO TEST (XI ABOVE) 
*         CVREGB - SIGN REGISTER (XL ABOVE) 
*         LOCALXY - LOCAL LABEL FOR FOLLOWING IN LINE CODE
*                            (IT MAY BE EITHER THE TRUE OR THE FALSE
*                            BRANCH DEPENDING ON THE POLARITY OF THE
*                            BRANCH VERB) 
* 
*         OUTPUTS:           (BESIDES CODE) 
*         LOCALXX - INITIALIZED AS TAGJ 
* 
  
 SGNJMPS  EGO    4
  
          NOTE   SGNJMPS
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
  
          GEN    ZR$,(VREFOF,CVREGF),LOCALXX
  
          IFZ    ((GSCODEOF,CONREGC),EQ,GFALSE),SGNJMP1    BRANCH = FLSE
  
*      BRANCH FIELD IS TRUE; LOCALXY = FALSE NODE 
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   PL$,(VREFOF,CVREGB),((FWA$OF,CONREGC))
          ELSEZ 
              GEN   NG$,(VREFOF,CVREGB),((FWA$OF,CONREGC))
          ENDIFZ
          GEN    EQ$,CVB0,CVB0,LOCALXY                     EQ  FALSE
          RETURN
  
 SGNJMP1  LABEL              FOR BRANCH FLD = FALSE; LOCALXY = TRUE 
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   PL$,(VREFOF,CVREGB),LOCALXY 
          ELSEZ 
              GEN   NG$,(VREFOF,CVREGB),LOCALXY 
          ENDIFZ
          GEN    EQ$,CVB0,CVB0,((FWA$OF,CONREGC))          EQ  FALSE
          RETURN
  
 SCF      EJECT 
* 
**        SCF -  SINGLE CHARACTER FIELD 
*                            FOR
*                IF POSITIVE AND IF NEGATIVE
* 
*                HANDLES BOTH LEADING AND TRAILING OVERPUNCHES
* 
*         GENERATES:  
*         SAI    X
*         MXJ    54 
*         LXI    LSC         (LEFT SHIFT COUNT - TO R JUST SIGN)
*         BXK    -XJ*XI 
*         SAL    XK+C.STRP
*         AXL    18 
*         SXM    XL 
*         ZR     XM,FALSE 
*         PL     XL,TRUE     (NG FOR IF NEG)
* 
* 
*         INPUT:  
*         T3 =   LSC (LEFT SHIFT COUNT) 
* 
  
 SCF      EGO    3
  
          NOTE   SCF
          GEN    SLRBPK,(VREGOF,CVREGA),CVB0,((FWA$OF,CONREGB)) 
          GEN    MASK,(VREGOF,CVREGB),54
          IFTHEN (LSC,LT,60)
              GEN   SHL,(VREFOF,CVREGA),LSC 
          ENDIFZ
          GEN    LIMP,(VREGOF,CVREGC),CVREGA,CVREGB 
          GEN    SLRXPK,(VREGOF,CVREGD),CVREGC,CPSTRP 
          GEN    SHR,CVREGD,18
          GEN    SXXPB,(VREGOF,CVREGE),CVREGD 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              MOVEZ (LOCLAB,LOCXX),LOCXX
              GEN   ZR$,(VREFOF,CVREGE),LOCALXX            ZR  XM,FALSE 
          ELSEZ 
              GEN   ZR$,(VREFOF,CVREGE),((FWA$OF,CONREGC)) ZR  XM,FALSE 
          ENDIFZ
  
          IFZ    ((GSCODEOF,CONREGC),EQ,GFALSE),SCF1
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   PL$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) PL  XL,TRUE
          ELSEZ 
              GEN   NG$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) NG  XL,TRUE
          ENDIFZ
          BRANCH SCF2 
  
 SCF1     LABEL 
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GPOSITV)
              GEN   NG$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) NG  XL,FALSE 
          ELSEZ 
           GEN      PL$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) PL  XL,FALSE 
          ENDIFZ
  
 SCF2     LABEL 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   LABEL$,LOCALXX               DEFINE LOCAL LABEL 
          ENDIFZ
  
          RETURN             SPLIT
  
  
 SCFN     EJECT 
* 
**        SCFN - SINGLE CHARACTER FIELDS - <NOT>
*                            FOR
*                IF NOT POSITVE AND IF NOT NEGATIVE 
* 
*                HANDLES BOTH LEADING AND TRAILING OVERPUNCHES
* 
*         GENERATES:  
*         SAI    X
*         MXJ    54 
*         LXI    LSC               (TO RIGHT JUST SIGN) 
*         BXK    -XJ*XI 
*         SAL    XK+C.STRP
*         NG     XL,TRUE     (PL FOR IF NOT NEG)
*         AXL    18 
*         SXM    XL 
*         ZR     XM,TRUE
* 
* 
*         INPUT:  
*         T3 -   LSC (LEFT SHIFT COUNT) 
* 
* 
  
 SCFN     EGO    3
  
          NOTE   SCFN 
          GEN    SLRBPK,(VREGOF,CVREGA),CVB0,((FWA$OF,CONREGB)) 
          GEN    MASK,(VREGOF,CVREGB),54
          IFTHEN (LSC,LT,60)
              GEN   SHL,(VREFOF,CVREGA),LSC 
          ENDIFZ
          GEN    LIMP,(VREGOF,CVREGC),CVREGA,CVREGB 
          GEN    SLRXPK,(VREGOF,CVREGD),CVREGC,CPSTRP 
  
          IFZ    ((GSCODEOF,CONREGC),EQ,GFALSE),SCFN1 
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GNOTPOS)
              GEN   NG$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) NG  XL,TRUE
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGD),((FWA$OF,CONREGC)) PL  XL,TRUE
          ENDIFZ
          BRANCH SCFN2
  
 SCFN1    LABEL 
  
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          IFTHEN ((GSCODEOF,CONREGA),EQ,GNOTPOS)
              GEN   NG$,(VREFOF,CVREGD),LOCALXX            NG  XL,TRUE
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGD),LOCALXX            PL  XL,TRUE
          ENDIFZ
  
 SCFN2    LABEL 
  
          GEN    SHR,CVREGD,18
          GEN    SXXPB,(VREGOF,CVREGE),CVREGD 
  
          IFTHEN ((GSCODEOF,CONREGC),EQ,GTRUE)
              GEN   ZR$,(VREFOF,CVREGE),((FWA$OF,CONREGC)) ZR  XM,TRUE
          ELSEZ 
              GEN   NZ$,(VREFOF,CVREGE),((FWA$OF,CONREGC)) NZ  XM,FALSE 
              GEN   LABEL$,LOCALXX               DEFINE TRUE BRANCH TAG 
          ENDIFZ
  
          RETURN             SPLIT
  
  
 SEPDISP  EJECT 
* 
**        SEPDISP - SIGN TESTS FOR SEPERATE CHARACTER ITEMS 
*                            ALSO VARIABLE SUBSCRIPTED ITEMS
* 
* 
*                WE USE GMOVE TO LOAD THE ITEM AS A NUMERIC 
*                            REGISTER ITEM - 10 CHARS OR MORE IN
*                            LENGTH IS D.P. 
* 
*         GENERATES:  
*                S.P. 
*         LOAD ITEM AS XI 
*         BXJ    XI 
*         AXJ    59 
*         BXK    XI-XJ       GETS ABS VALUE 
*         SAL    =XC.ZERO 
*         IXQ    XK-XL       BRANCHING (BELOW) IS ON XQ 
* 
*                D.P. 
*         LOAD ITEM INTO XI + XJ
*         BXK    XI 
*         AXK    59 
*         BXL    XI-XK       GET ABS VALUE
*         BXM    XJ-XK
*         SAN    =XC.ZERO 
*         IXO    XL-XN
*         IXP    XM-XN
*         BXQ    XO+XP
* 
*         BRANCHING:         (EXPECTS CVREGA TO CONTAIN REGISTER NR)
*                THERE ARE FOUR BRANCH CASES: 
* 
*         CASE 1 - IF POS/TRUE, NOT POS/FALSE 
*         ZR     XQ,LOCALXX 
*         PL     XI,TAG 
*LOCALXX  BSS    0
* 
* 
*         CASE 2 - IF NEG/TRUE,  NOT NEG/FALSE
*         ZR     XQ,LOCALXX 
*         NG     XI,TAG 
*LOCALXX  BSS    0
* 
* 
*         CASE 3 - IF POS/FALSE,  NOT POS/TRUE
*         ZR     XQ,TAG 
*         NG     XI,TAG 
* 
* 
*         CASE 4 - IF NEG/FALSE,  NOT NEG/TRUE
*         ZR     XQ,TAG 
*         PL     XI,TAG 
* 
* 
* 
* 
  
 SEPDISP  EGO    3
  
          MOVEZ  CONREGC,CONREGI   SAVE BRANCH FIELD
          MOVEZ  (EQUALS,CREG11),CONREGT
          CALLZ  ADNAT
          MOVEZ  (EQUALS,CREG11),CONREGC
  
*      SET UP DUMMY FOR GMOVE 
  
          MOVEZ  COMP,(TYPEOF,CONREGC)
          MOVEZ  (NUMLENOF,CONREGB),(NUMLENOF,CONREGC)
          MOVEZ  (POINTOF,CONREGB),(POINTOF,CONREGC)
          MOVEZ  0,(BCPOF,CONREGC)
          MOVEZ  0,(LDSIGNOF,CONREGC) 
          MOVEZ  1,(SIGNOF,CONREGC) 
  
          CALLZ  MOVER
  
          NOTE   SEPDISP
          GEN    XMIT,(VREGOF,CVREGA),(TREGOF,CONREGC)
          GEN    SHR,CVREGA,59
          GEN    LXOR,(VREGOF,CVREGB),(TREGOF,CONREGC),CVREGA 
  
          IFTHEN ((NUMLENOF,CONREGC),LT,10) 
            GEN    SLRBPK,(VREGOF,CVREGC),,CPZERO 
            GEN    ISUB,(VREGOF,CVREGA),CVREGB,CVREGC 
          ELSEZ 
            GEN    LXOR,(VREGOF,CVREGC),(TREGP1OF,CONREGC),CVREGA 
            GEN    SLRBPK,(VREGOF,CVREGD),,CPZERO 
            GEN    ISUB,(VREGOF,CVREGE),CVREGB,CVREGD 
            GEN    ISUB,(VREGOF,CVREGB),CVREGC,CVREGD 
            GEN    LOR,(VREGOF,CVREGA),CVREGE,CVREGB
          ENDIFZ
  
*      BRANCHING CODE FOLLOWS 
  
          IFTHEN ((GSCODEOF,CONREGI),EQ,GTRUE)
            GOTOCASE (GSCODEOF,CONREGA) 
              CASE   GPOSITV,SEPCS1 
              CASE   GNEGATV,SEPCS2 
              CASE   GNOTPOS,SEPCS3 
              CASE   GNOTNEG,SEPCS4 
            ENDCASE 
            ERROR  CONERR2         UNKNOWN CONDITION
          ELSEZ 
            GOTOCASE (GSCODEOF,CONREGA) 
              CASE   GPOSITV,SEPCS3 
              CASE   GNEGATV,SEPCS4 
              CASE   GNOTPOS,SEPCS1 
              CASE   GNOTNEG,SEPCS2 
            ENDCASE 
            ERROR  CONERR2
          ENDIFZ
  
*      CASE 1 
  
 SEPCS1   LABEL 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    ZR$,CVREGA,LOCALXX 
          GEN    PL$,(TREGOF,CONREGC),((FWA$OF,CONREGI))
          GEN    LABEL$,LOCALXX 
          BRANCH SEPDISP2 
  
*      CASE 2 
  
 SEPCS2   LABEL 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    ZR$,CVREGA,LOCALXX 
          GEN    NG$,(TREGOF,CONREGC),((FWA$OF,CONREGI))
          GEN    LABEL$,LOCALXX 
          BRANCH SEPDISP2 
  
*      CASE 3 
  
 SEPCS3   LABEL 
          GEN    ZR$,CVREGA,((FWA$OF,CONREGI))
          GEN    NG$,(TREGOF,CONREGC),((FWA$OF,CONREGI))
          BRANCH SEPDISP2 
  
*      CASE 4 
  
 SEPCS4   LABEL 
          GEN    ZR$,CVREGA,((FWA$OF,CONREGI))
          GEN    PL$,(TREGOF,CONREGC),((FWA$OF,CONREGI))
  
 SEPDISP2 LABEL 
          CALLZ  SUBDNAT
          RETURN             SPLIT
  
  
 SIGNTMP  EJECT 
**        SIGNTMP - SIGN TESTS ON DISPLAY CODE REGISTER ITEMS 
* 
*                WE CONVERT IF POSITIVE TO IF GREATER AND CALL
*                SPBRNCH OR DPBRNCH.  THIS IS DONE BY CHANGING
*                THE GSCODEOF,CONREGA FIELD.
* 
*         * * * * *          (GSCODEOF,CONREGA) IS STORED INTO HERE 
*         * * * * *          (GSCODEOF,CONREGA) IS STORED INTO HERE 
* 
* 
 SIGNTMP  EGO    3
          NOTE SIGNTMP
          MOVEZ  CONREGC,CONREGI
          MOVEZ  CONREGB,CONREGD
  
          GOTOCASE (GSCODEOF,CONREGA) 
            CASE   GPOSITV,STMP1
            CASE   GNEGATV,STMP2
            CASE   GNOTPOS,STMP3
            CASE   GNOTNEG,STMP4
          ENDCASE 
          ERROR  CONERR2     UNKNOWN CONDITION
  
 STMP1    LABEL 
          MOVEZ  GGREATER,(GSCODEOF,CONREGA)
          BRANCH STMP5
  
 STMP2    LABEL 
          MOVEZ  GLESS,(GSCODEOF,CONREGA) 
          BRANCH STMP5
  
 STMP3    LABEL 
          MOVEZ  GNOTGT,(GSCODEOF,CONREGA)
          BRANCH STMP5
  
 STMP4    LABEL 
          MOVEZ  GNOTLT,(GSCODEOF,CONREGA)
  
 STMP5    LABEL 
          IFZ    ((NUMLENOF,CONREGD),GT,9),STMP6
          MOVEZ  1,DSPFLG    SET DISPLAY CODE FLAG
          CALLZ  SPBRNCH
          RETURN
  
 STMP6    LABEL 
          MOVEZ  CREG11,CONREGT 
          CALLZ  ADNAT
          BRANCH DPBRNCH
 SWITCHGN TITLE  SWITCHGN - SENSE SWITCH CONDITIONS 
* 
**        SWITCHGN - IF SWITCH AND IF NOT SWITCH CONDITIONS 
* 
*                EXPECTS THE SWITCH NUMBER IN THE G-POINTER FILED 
*                OF CONREGB 
* 
*         GENERATES:  
*         SAI    B0 
*         LXI    54-SW NR 
*         NG     XI,TRUE     (PL FOR IF NOT SWITCH) 
* 
* 
  
 SWITCHGN EGO    1
  
          NOTE   SWITCHGN 
          IFTHEN ((GSCODEOF,CONREGB),EQ,GDBGSWIT) 
            MOVEZ  48,T9
            GEN    SLRBPB,(VREGOF,CVREGA),CVB0,CVB0 
          ELSEZ 
            IFZ    ((WRDOFFOF,CONREGB),GT,6),SWITCH1
            SUBZ   54,(WRDOFFOF,CONREGB),T9 
            GEN    SLRBPB,(VREGOF,CVREGA),CVB0,CVB0 
            BRANCH SWITCH2
 SWITCH1    LABEL 
            SUBZ  (WRDOFFOF,CONREGB),7,T1 
            QUOTZ  T1,60,T1 
            GEN   SLRBPK,(VREGOF,CVREGA),,((EXT$OF,C.SWTCH),T1) 
            SUBZ   (WRDOFFOF,CONREGB),7,T1
            MOVEZ  (ARITH9,T1),T9       (SWITCH -7) MOD 60
 SWITCH2    LABEL 
          ENDIFZ
          GEN    SHL,(VREFOF,CVREGA),T9 
  
          IFZ    ((GSCODEOF,CONREGC),EQ,GFALSE),SSW1
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GSWITCH)
              GEN   NG$,(VREFOF,CVREGA),((FWA$OF,CONREGC)) NG  XI,TRUE
          ELSEZ 
              GEN   PL$,(VREFOF,CVREGA),((FWA$OF,CONREGC)) PL  XI,TRUE
          ENDIFZ
          RETURN
  
 SSW1     LABEL 
  
          IFTHEN ((GSCODEOF,CONREGA),EQ,GSWITCH)
              GEN   PL$,(VREFOF,CVREGA),((FWA$OF,CONREGC)) PL  XI,FALSE 
          ELSEZ 
              GEN   NG$,(VREFOF,CVREGA),((FWA$OF,CONREGC)) NG  XI,FALSE 
          ENDIFZ
          RETURN
  
  
  
          TITLE  MISC HANDY SUBROUTINES 
 BRGBRNCH EJECT 
* 
**        BRGBRNCH - B REGISTER BRANCHES FOR A VS B OBJECT ROUTINE
*                            COMPARISONS (LIKE C.BCDCM) 
* 
*                EXPECTS VIRTUAL REGISTER FOR B-REG IN CVREGA 
*                            POSSIBLE VALUES: 
*                            0     A = B
*                            +1    A > B
*                            -1    A < B
*                AND THE BRANCH NODE IN CONREGI.
* 
* 
*                THE CODE GENERATED DEPENDS UPON
*                            (1)   THE VERB 
*                            (2)   THE "POLARITY" OF THE BRANCH NODE
* 
* 
*                THERE ARE SIX POSSIBLE CASES GENERATED:  
* 
*         CASE 1 (USED FOR IF EQ/TRUE + IF NEQ/FALSE) 
* 
*         EQ     B3,B0,TAG
* 
* 
*         CASE 2 (USED FOR IF EQ/FALSE + IF NEQ/TRUE) 
* 
*         NE     B3,B0,TAG
* 
* 
*         CASE 3 (USED FOR IF GT/TRUE + IF NGT/FALSE) 
* 
*         EQ     B3,B1,TAG
* 
* 
*         CASE 4 (USED FOR IF GT/FALSE + IF NGT/TRUE) 
* 
*         LT     B3,B1,TAG
* 
* 
*         CASE 5 (USED FOR IF LT/TRUE + IF NLT/FALSE) 
* 
*         LT     B3,B0,TAG
* 
* 
*         CASE 6 (USED FOR IF LT/FALSE + IF NLT/TRUE) 
* 
*         GE     B3,B0,TAG
* 
* 
* 
*         FOR COMPARE VERBS:  
* 
*         LT     B0,BI,TAGI 
*         LT     BI,B0,TAGE 
* 
* 
* 
 BRGBRNCH EGO    4
          NOTE   BRGBRNCH 
          IFZ    ((GSCODEOF,CONREGA),EQ,GCOMPARE),BBCOMP
          IFTHEN ((GSCODEOF,CONREGI),EQ,GTRUE)
            GOTOCASE  (GSCODEOF,CONREGA)
              CASE   GEQUAL,BBCS1 
              CASE   GGREATER,BBCS3 
              CASE   GLESS,BBCS5
              CASE   GNOTEQ,BBCS2 
              CASE   GNOTGT,BBCS4 
              CASE   GNOTLT,BBCS6 
            ENDCASE 
            ERROR  CONERR2         UNKNOWN CONDITION
          ELSEZ 
            GOTOCASE  (GSCODEOF,CONREGA)
              CASE   GEQUAL,BBCS2 
              CASE   GGREATER,BBCS4 
              CASE   GLESS,BBCS6
              CASE   GNOTEQ,BBCS1 
              CASE   GNOTGT,BBCS3 
              CASE   GNOTLT,BBCS5 
            ENDCASE 
            ERROR  CONERR2         UNKNOWN CONDITION
          ENDIFZ
 BBCS1    LABEL 
          GEN    EQ$,CVREGA,CVB0,((FWA$OF,CONREGI)) 
          RETURN
          SPACE  4
 BBCS2    LABEL 
          GEN    NE$,CVREGA,CVB0,((FWA$OF,CONREGI)) 
          RETURN
          SPACE  4
 BBCS3    LABEL 
          GEN    EQ$,CVREGA,CVB1,((FWA$OF,CONREGI)) 
          RETURN
          SPACE  4
 BBCS4    LABEL 
          GEN    LT$,CVREGA,CVB1,((FWA$OF,CONREGI)) 
          RETURN
          SPACE  4
 BBCS5    LABEL 
          GEN    LT$,CVREGA,CVB0,((FWA$OF,CONREGI)) 
          RETURN
          SPACE  4
 BBCS6    LABEL 
          GEN    GE$,CVREGA,CVB0,((FWA$OF,CONREGI)) 
          RETURN
 BBCOMP   SPACE  4
 BBCOMP   LABEL 
          GEN    LT$,,CVREGA,((FWA$OF,CONREGI)) 
          GEN    LT$,CVREGA,,((FWA$OF,CONREGE)) 
          RETURN
 CALLOBJ  EJECT 
* 
**        CALLOBJ - GENERATE CALL TO C.BCDCM OR C.LITCM 
* 
*                C.BCDCM HANDLES A VS B FOR TWO DATA ITEMS OR 
*                            LITERALS (NOT "ALL" TYPE)
*                C.LITCM HANDLES A VS B WHERE ONE ITEM IS AN "ALL"
*                            LITERAL
* 
*         CODE GENERATED: 
* 
*         SX1    BYTE OFFSET OF A 
*         SX2    BYTE OFFSET OF B 
*         SB3    BASE ADDR OF A 
*         SB4    BASE ADDR OF B 
*         SB5    LENGTH OF A (BYTES)
*         SB6    LENGTH OF B (BYTES)
* 
*         SB7    0;  A IS LIT      (C.LITCM ONLY) 
*                1;  B IS LIT      (C.LITCM ONLY) 
* 
*         RJ     =XC.BCDCM         (OR C.LITCM) 
* 
* 
*                BOTH ROUTINES RETURN:  
*         B3 = 0 A =B 
*            = 1 A >B 
*            =-1 A <B 
*                            WE CALL BRGBRNCH TO GENERATE THE 
*                            PROPER BRANCHING 
* 
* 
 CALLOBJ  EGO    4
          NOTE   CALLOBJ
          MOVEZ  CONREGD,CONREGI
          IFTHEN ((GCODEOF,CONREGB),EQ,GLITREF) 
            IFZ    ((SPACESOF,CONREGB),NE,0),COSPACE
          ENDIFZ
          IFTHEN ((GCODEOF,CONREGC),EQ,GLITREF) 
            IFZ    ((SPACESOF,CONREGC),NE,0),COSPACE1 
          ENDIFZ
          IFTHEN ((GSCODEOF,CONREGB),NE,0)       C.F. SUBSCRIPTING
            MOVEZ  CONREGB,P2 
            CALLZ  SUBREF 
            MOVEZ  P3,CVREGA
            GEN    SBXPB,(VREGOF,CVREGE),P4 
          ELSEZ 
            GEN    SXBPK,(VREGOF,CVREGA),,(BCPOF,CONREGB)  NO SUBS
          ENDIFZ
          IFTHEN ((GSCODEOF,CONREGC),NE,0)
            MOVEZ  CONREGC,P2 
            CALLZ  SUBREF 
            MOVEZ  P3,CVREGB
            GEN    SBXPB,(VREGOF,CVREGF),P4 
          ELSEZ 
            GEN    SXBPK,(VREGOF,CVREGB),,(BCPOF,CONREGC) 
          ENDIFZ
          IFZ    ((LATALLOF,CONREGB),NE,0),COBJ2
          IFZ    ((LATALLOF,CONREGC),NE,0),COBJ4
  
*      ONLY SIMPLE C.BCDCM CALL REMAINS 
  
          GEN    SBBPK,(VREGOF,CVREGC),CVB0,((FWA$OF,CONREGB))
          GEN    SBBPK,(VREGOF,CVREGD),CVB0,((FWA$OF,CONREGC))
  
          IFTHEN ((TYPEOF,CONREGB),EQ,VARGROUP) 
            MOVEZ  CONREGB,CONREGM
            PUSH  CVREGA,CVREGB,CVREGC,CVREGD 
            CALLZ  GETSZVG
            POP  CVREGA,CVREGB,CVREGC,CVREGD
            GEN    SBXPB,(VREGOF,CVREGE),P1 
          ENDIFZ
          IFTHEN ((TYPEOF,CONREGB),NE,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGB),EQ,0)
            GEN    SBBPK,(VREGOF,CVREGE),,(BYTLENOF,CONREGB)
          ENDIFZ
  
          IFTHEN ((TYPEOF,CONREGC),EQ,VARGROUP) 
            MOVEZ  CONREGC,CONREGM
            PUSH  CVREGA,CVREGB,CVREGC,CVREGD,CVREGE
            CALLZ  GETSZVG
            POP  CVREGA,CVREGB,CVREGC,CVREGD,CVREGE 
            GEN    SBXPB,(VREGOF,CVREGF),P1 
          ENDIFZ
          IFTHEN ((TYPEOF,CONREGC),NE,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGC),EQ,0)
            GEN    SBBPK,(VREGOF,CVREGF),,(BYTLENOF,CONREGC)
          ENDIFZ
  
          GENOBJ N=C.BCDCM,I=(CVREGA,CVREGB,CVREGC,CVREGD,CVREGE,CVREGF)
,,O=((VREGOF,CVREGA)) 
          CALLZ  BRGBRNCH 
          RETURN
          SPACE  4
  
*      ITEM "A" IS AN ALL LIT 
  
 COBJ2    LABEL 
          IFTHEN ((FIGVALOF,CONREGB),NE,0)       CHECK FOR LOW/HIGH VAL 
            SUBZ   (FIGVALOF,CONREGB),1,T6                 SETS LO/HI 
            GEN    SBBPK,(VREGOF,CVREGC),CVB0,CPLOVAL      REFS LO/HI 
            GEN    SBBPK,(VREGOF,CVREGE),CVB0,10
          ELSEZ 
            GEN    SBBPK,(VREGOF,CVREGC),CVB0,((FWA$OF,CONREGB))
            GEN    SBBPK,(VREGOF,CVREGE),CVB0,(BYTLENOF,CONREGB)
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGD),CVB0,((FWA$OF,CONREGC))
          IFTHEN ((TYPEOF,CONREGC),EQ,VARGROUP) 
            PUSH   CVREGA,CVREGB,CVREGC,CVREGD,CVREGE 
            MOVEZ  CONREGC,CONREGM
            CALLZ  GETSZVG
            GEN    SBXPB,(VREGOF,CVREGF),P1 
            POP    CVREGA,CVREGB,CVREGC,CVREGD,CVREGE 
          ENDIFZ
          IFTHEN ((TYPEOF,CONREGC),NE,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGC),EQ,0)
            GEN    SBBPK,(VREGOF,CVREGF),,(BYTLENOF,CONREGC)
          ENDIFZ
          GEN    SBBPB,(VREGOF,CVREGG),CVB0,CVB0
          GENOBJ N=C.LITCM,I=(CVREGA,CVREGB,CVREGC,CVREGD,CVREGE,CVREGF,
,CVREGG),O=((VREGOF,CVREGA))
          CALLZ  BRGBRNCH 
          RETURN
          SPACE  4
  
*      ITEM "B" IS AN ALL LITERAL 
  
 COBJ4    LABEL 
          GEN    SBBPK,(VREGOF,CVREGC),CVB0,((FWA$OF,CONREGB))
          IFTHEN ((TYPEOF,CONREGB),EQ,VARGROUP) 
            PUSH   CVREGA,CVREGB,CVREGC 
            MOVEZ  CONREGB,CONREGM
            CALLZ  GETSZVG
            GEN    SBXPB,(VREGOF,CVREGE),P1 
            POP    CVREGA,CVREGB,CVREGC 
          ENDIFZ
          IFTHEN ((TYPEOF,CONREGB),NE,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGB),EQ,0)
            GEN    SBBPK,(VREGOF,CVREGE),,(BYTLENOF,CONREGB)
          ENDIFZ
  
*      CHECK FOR LOW OR HIGH VALVES NOT IN LIT POOL + REF C.LOVAL+T6
*                            INSTEAD
  
          IFTHEN ((FIGVALOF,CONREGC),NE,0)
            SUBZ   (FIGVALOF,CONREGC),1,T6                BUILD OFFSET
            GEN    SBBPK,(VREGOF,CVREGD),CVB0,CPLOVAL 
            GEN    SBBPK,(VREGOF,CVREGF),CVB0,10
          ELSEZ 
            GEN    SBBPK,(VREGOF,CVREGD),CVB0,((FWA$OF,CONREGC))
            GEN    SBBPK,(VREGOF,CVREGF),CVB0,(BYTLENOF,CONREGC)
          ENDIFZ
          GEN    SBBPB,(VREGOF,CVREGG),CVB0,CVB1
          GENOBJ N=C.LITCM,I=(CVREGA,CVREGB,CVREGC,CVREGD,CVREGE,CVREGF,
,CVREGG),O=((VREGOF,CVREGA))
          CALLZ  BRGBRNCH 
          RETURN
  
 COSPACE  EJECT 
*         COSPACE - HANDLE A VS B WHERE EITHER A OR B IS ALL SPACES.
* 
*                SETS CALL TO C.BCDCM WITH POINTER TO C.BLANKS
* 
  
 COSPACE  LABEL              A IS SPACES
          NOTE   COSPACE
          MOVEZ  (BYTLENOF,CONREGC),LNTHB        SIZE OF B
 IF3248   IFEQ   OP.BDP,OP.YES
          IFTHEN (LNTHB,GT,SPACESZ)              SIZE B VS SIZE C.SPACE 
            MOVEZ  SPACESZ,LNTHA                 USE SIZE OF C.SPACE
          ELSEZ 
            MOVEZ  LNTHB,LNTHA                   USE SIZE OF FIELD
          ENDIFZ
 IF3248   ELSE
          MOVEZ  MWDLNTH,LNTHA                   USE CHARS PER WORD 
 IF3248   ENDIF 
          IFTHEN ((TYPEOF,CONREGC),EQ,VARGROUP) 
            MOVEZ  CONREGC,CONREGM
            CALLZ  GETSZVG
            GEN    SBXPB,(VREGOF,CVREGF),P1 
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGC),,CPBLANK 
  
          IFTHEN ((GSCODEOF,CONREGC),NE,0)       IF B IS SUBSCRIPTED
            MOVEZ  CONREGC,P2 
          PUSH   LNTHA,LNTHB                     SAVE SIZES 
            CALLZ  SUBREF 
          POP    LNTHA,LNTHB
            MOVEZ  P3,CVREGB
            GEN    SBXPB,(VREGOF,CVREGF),P4 
            GEN    SXBPB,(VREGOF,CVREGA),,CVB0
            GEN    SBBPK,(VREGOF,CVREGE),,LNTHA 
          ELSEZ 
            GEN    SXBPK,(VREGOF,CVREGB),,(BCPOF,CONREGC) 
            GEN    SXXPB,(VREGOF,CVREGA),CVREGB 
            SUBZ   MWDLNTH,(BCPOF,CONREGC),P1 
            GEN    SBBPK,(VREGOF,CVREGE),,P1
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGD),,((FWA$OF,CONREGC) 
          IFTHEN ((TYPEOF,CONREGC),NE,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGC),EQ,0)
            GEN    SBBPK,(VREGOF,CVREGF),,LNTHB 
          ENDIFZ
          BRANCH COSPACE2 
  
 COSPACE1 SPACE  4
 COSPACE1 LABEL              B IS SPACES
          NOTE   COSPACE1 
          MOVEZ  (BYTLENOF,CONREGB),LNTHA        SIZE OF A
 IF3276   IFEQ   OP.BDP,OP.YES
          IFTHEN (LNTHA,GT,SPACESZ)              SIZE A VS SIZE C.SPACE 
            MOVEZ  SPACESZ,LNTHB                 USE SIZE OF C.SPACE
          ELSEZ 
            MOVEZ  LNTHA,LNTHB                   USE SIZE OF FIELD
          ENDIFZ
 IF3276   ELSE
          MOVEZ  MWDLNTH,LNTHB                   USE CHARS PER WORD 
 IF3276   ENDIF 
          IFTHEN ((TYPEOF,CONREGB),EQ,VARGROUP) 
            MOVEZ  CONREGB,CONREGM
            CALLZ  GETSZVG
            GEN    SBXPB,(VREGOF,CVREGE),P1 
          ENDIFZ
          IFTHEN ((GSCODEOF,CONREGB),NE,0)       C.F. SUBSCRIPTING
            MOVEZ  CONREGB,P2 
          PUSH   LNTHA,LNTHB       SAVE LENGTHS 
            CALLZ  SUBREF 
          POP    LNTHA,LNTHB
            MOVEZ  P3,CVREGA
            GEN    SBXPB,(VREGOF,CVREGE),P4 
            GEN    SXBPB,(VREGOF,CVREGB),,CVB0
            GEN    SBBPK,(VREGOF,CVREGF),,LNTHB 
          ELSEZ 
            GEN    SXBPK,(VREGOF,CVREGA),,(BCPOF,CONREGB) 
            GEN    SXXPB,(VREGOF,CVREGB),CVREGA 
            SUBZ   MWDLNTH,(BCPOF,CONREGB),P1 
            GEN    SBBPK,(VREGOF,CVREGF),,P1
          ENDIFZ
          GEN    SBBPK,(VREGOF,CVREGC),,((FWA$OF,CONREGB))
          IFTHEN ((TYPEOF,CONREGB),NE,VARGROUP) 
          ANDIF  ((GSCODEOF,CONREGB),EQ,0)
            GEN    SBBPK,(VREGOF,CVREGE),,LNTHA 
          ENDIFZ
  
          GEN    SBBPK,(VREGOF,CVREGD),,CPBLANK 
  
 COSPACE2 SPACE  4
 COSPACE2 LABEL 
          GENOBJ N=C.BCDCM,I=(CVREGA,CVREGB,CVREGC,CVREGD,CVREGE,CVREGF)
,,O=((VREGOF,CVREGA)) 
          CALLZ  BRGBRNCH 
          RETURN
  
 FFB      EJECT 
* 
**        FFB -  FORCE FALSE BRANCH 
* 
*                GENERATE SPECIAL CASE BRANCH CODE- 
* 
*                IF THE BRANCH FIELD SUBCODE IS FALSE,
*                            GENERATE 
*                            EQ    FALSE
*                ELSE 
*                            GENERATE NO CODE 
* 
* 
 FFB      EGO    3
  
          IFZ    ((GSCODEOF,CONREGC),EQ,GTRUE),FFB1        JUST RETURN
  
          NOTE   FFB
          GEN    EQ$,CVB0,CVB0,((FWA$OF,CONREGC)) 
  
 FFB1     LABEL 
  
          RETURN
  
 FTB      EJECT 
* 
**        FTB -  FORCE TRUE BRANCH
* 
*                GENERATE SPECIAL CASE BRANCH CODE
* 
*                IF THE BRANCH FIELD SUBCODE IS TRUE, 
*                            GENERATE 
*                            EQ    TRUE 
*                ELSE 
*                            GENERATE NO CODE 
* 
* 
 FTB      EGO    3
  
          IFZ    ((GSCODEOF,CONREGC),EQ,GFALSE),FTB1       SCRAM
  
          NOTE   FTB
          GEN    EQ$,CVB0,CVB0,((FWA$OF,CONREGC)) 
  
 FTB1     LABEL 
  
          RETURN             SPLIT THE SCENE
  
 GBB      EJECT 
* 
**        GBB -  GENERATE B-REGISTER BRANCH 
* 
*                GBB EXPECTS CVREGA WITH THE VIRTUAL REGISTER TO USE
* 
*             GENERATES:  
*         EQ     B0,B-,TRUE  (OR FALSE IF <NOT> CONDITION)
*             OR
*         NE     B0,B-,FALSE (OR TRUE IF <NOT> CONDITION) 
* 
 GBB      EGO    3
          NOTE   GBB
* 
          CALLZ  IFNOT       DO WE HAVE A <NOT> 
  
          IFZ    (P1,EQ,(EQUALS,1)),GBBNOT       HAVE A <NOT> 
  
          IFTHEN    ((GSCODEOF,CONREGC),EQ,GTRUE) 
              GEN   EQ$,CVB0,CVREGA,((FWA$OF,CONREGC))   EQ  B0,B-,PNAT 
          ELSEZ 
              GEN   NE$,CVB0,CVREGA,((FWA$OF,CONREGC))   NE  B0,B-,PNAT 
          ENDIFZ
  
          RETURN             SPLIT
* 
* 
 GBBNOT   LABEL 
  
          IFTHEN    ((GSCODEOF,CONREGC),EQ,GTRUE) 
              GEN   NE$,CVB0,CVREGA,((FWA$OF,CONREGC)    NE  B0,B-,PNAT 
          ELSEZ 
              GEN   EQ$,CVB0,CVREGA,((FWA$OF,CONREGC))   EQ  B0,B-,PNAT 
          ENDIFZ
  
          RETURN             SPLIT
* 
* 
 GENCC    EJECT 
**        GENCC - GENERATE COMPARE COLLATED INSTRUCTIONS
* 
*                THIS ROUTINE IS ACTIVE ONLY IF THE CMU IS
*                            ASSEMBLED ON (OP.BDP=OP.YES) 
* 
*                GENERATES ONE OR MORE COMPARE COLLATED INSTRUCTIONS
*                            TO PROPERLY COMPARE THE ITEMS. 
* 
*         GENERATES:  
* 
*         SAI    =XC.PRGCS
*         SA0    XI 
*         CC     127,FWA,BCPA,FWAB,BCPB          ONLY IF FLD > 127 CHARS
*         NZ     X0,LOCALXX 
*         . 
*         . 
*         CC     LLEFT,FWA+,BCPA+,FWAB+,BCPB+ 
*LOCALXX  BSS    0
* 
*                THE BRANCHING AT THE END IS DONE BY SPBRNCH
* 
*                EXPECTS BRANCH SUBVERB IN CONREGD
* 
*                IF THE FLAG -DSPFLG- IS 0, BOTH ITEMS ARE RESIDENT 
*                            IN WORKING-STORAGE AS USUAL.  IF -DSPFLG-
*                            IS 1, ITEM A IS IN C.TEMP; IF IT IS 2, 
*                            ITEM B IS IN C.TEMP. 
* 
* 
 IFI      IFEQ   OP.BDP,OP.YES     ONLY IF A CMU AROUND 
  
 GENCC    EGO    4
  
          MOVEZ  CONREGD,CONREGI   FOR SPBRNCH
          MOVEZ  (BYTLENOF,CONREGB),LNTHA 
          MOVEZ  (BYTLENOF,CONREGC),LNTHB 
          MOVEZ  (BCPOF,CONREGB),NBCPA
          MOVEZ  (BCPOF,CONREGC),NBCPB
          IFZ    ((GCODEOF,CONREGB),NE,GLITREF),GENCC2
          IFTHEN ((SPACESOF,CONREGB),NE,0)
            MOVEZ  0,LNTHA
            MOVEZ  0,NBCPA
          ENDIFZ
  
 GENCC2   LABEL 
          IFZ    ((GCODEOF,CONREGC),NE,GLITREF),GENCC4
          IFTHEN ((SPACESOF,CONREGC),NE,0)
            MOVEZ  0,LNTHB
            MOVEZ  0,NBCPB
          ENDIFZ
  
 GENCC4   LABEL 
          MOVEZ  0,USECU     CLEAR COMPARE UNCOLLATED FLAG
          MOVEZ  0,T1        CLEAR LOCAL LABEL FLAG 
*      TESTS FOR EQUAL OR UNEQUAL MAY USE THE UNCOLLATED COMPARE
*      INSTRUCTION IF A USER DEFINED COLLATING SEQUENCE HAS NOT DEFINED 
*      CHARACTERS COLLATING EQUIVALENTLY (VIA ALSO) - USE CCTANALSO 
          IFTHEN ((GSCODEOF,CONREGA),EQ,GNOTEQ)  SEE IF NOT EQUAL COMPAR
          ANDIF  ((CCTBIT,ANALSO),EQ,0)          SEE IF ALSO IN UD COLSQ
            MOVEZ  1,USECU   FLAG TO USE UNCOLLATED COMPARE 
          ENDIFZ
          IFTHEN ((GSCODEOF,CONREGA),EQ,GEQUAL)  SEE IF EQUAL COMPARE 
          ANDIF  ((CCTBIT,ANALSO),EQ,0)          SEE IF ALSO IN UD COLSQ
            MOVEZ  1,USECU   FLAG TO USE UNCOLLATED COMPARE 
          ENDIFZ
          MINZ   LNTHA,LNTHB,MNLNTH 
          MAXZ   LNTHA,LNTHB,MXLNTH 
          MOVEZ  0,WRDOFF 
          MOVEZ  0,WRDOFFC
  
          NOTE   GENCC
          IFTHEN (USECU,EQ,0)      TEST FOR UNCOLLATED COMPARE
            GEN    SLRBPK,(VREGOF,CVREGA),,CBPRGCS  FETCH PROG CS 
            GEN    SAXPB,(VREGOF,CVREGB),CVREGA  SET A0 TO IT 
          ENDIFZ
  
          IFZ    (DSPFLG,EQ,0),GENCC12
          IFZ    (DSPFLG,EQ,2),GENCC8 
          MOVEZ  0,NBCPA
  
          IFZ    (MNLNTH,EQ,0),GENCC5  JP IF COMPARISON AGAINST SPACES
          IFTHEN (USECU,EQ,0)      TEST FOR UNCOLLATED COMPARE
            GEN    CC$,MNLNTH,CBTEMP,0,FWCPLUS,NBCPB,(VREGOF,CVREGA),CVR
,EGB
          ELSEZ 
            GEN    CU$,MNLNTH,CBTEMP,0,FWCPLUS,NBCPB,(VREGOF,CVREGA)
          ENDIFZ
          IFZ    (LNTHA,EQ,LNTHB),GENCC30 
          MOVEZ  (LOCLAB,T1),T1 
          GEN    NZ$,CVREGA,LOCALXX 
 GENCC5   LABEL 
          IFZ    (LNTHA,LT,LNTHB),GENCC6
  
          ADDZ   MNLNTH,NBCPA,NCA 
          QUOTZ  NCA,10,WRDOFF
          REMZ   NCA,10,NBCPA 
          SUBZ   LNTHA,MNLNTH,MNLNTH
          IFTHEN (USECU,EQ,0)      TEST FOR UNCOLLATED COMPARE
            GEN    CC$,MNLNTH,TMPPLUS,NBCPA,CPBLANK,0,(VREGOF,CVREGA),CV
,REGB 
          ELSEZ 
            GEN    CU$,MNLNTH,TMPPLUS,NBCPA,CPBLANK,0,(VREGOF,CVREGA) 
          ENDIFZ
          BRANCH GENCC30
  
 GENCC6   LABEL 
          SUBZ   LNTHA,MNLNTH,LNTHA    LNTHA IS NOW 0 
          SUBZ   LNTHB,MNLNTH,LNTHB 
          BRANCH GENCC18
  
 GENCC8   LABEL              ITEM B IS IN C.TEMP
          MOVEZ  0,NBCPB     SET BCP TO 0 
          IFZ    (MNLNTH,EQ,0),GENCC9  JP IF COMPARISON AGAINST SPACES
          IFTHEN (USECU,EQ,0)      TEST FOR UNCOLLATED COMPARE
            GEN    CC$,MNLNTH,FWAPLUS,NBCPA,CBTEMP,0,(VREGOF,CVREGA),CVR
,EGB
          ELSEZ 
            GEN    CU$,MNLNTH,FWAPLUS,NBCPA,CBTEMP,0,(VREGOF,CVREGA)
          ENDIFZ
          IFZ    (LNTHB,EQ,LNTHA),GENCC30 
          MOVEZ  (LOCLAB,T1),T1 
          GEN    NZ$,CVREGA,LOCALXX 
 GENCC9   LABEL 
          IFZ    (LNTHB,LT,LNTHA),GENCC10 
  
          ADDZ   MNLNTH,NBCPB,NCA 
          QUOTZ  NCA,10,WRDOFF
          REMZ   NCA,10,NBCPB 
          SUBZ   LNTHB,MNLNTH,MNLNTH
          IFTHEN (USECU,EQ,0)      TEST FOR UNCOLLATED COMPARE
            GEN    CC$,MNLNTH,CPBLANK,0,TMPPLUS,NBCPB,(VREGOF,CVREGA),CV
,REGB 
          ELSEZ 
            GEN    CU$,MNLNTH,CPBLANK,0,TMPPLUS,NBCPB,(VREGOF,CVREGA) 
          ENDIFZ
          BRANCH GENCC30
  
 GENCC10  LABEL 
          SUBZ   LNTHA,MNLNTH,LNTHA 
          MOVEZ  0,LNTHB
          BRANCH GENCC16
  
 GENCC12 SPACE 4
 GENCC12  LABEL 
          IFZ    (MXLNTH,LE,127),GENCC24
          MAXZ   LNTHA,LNTHB,TEMP 
          MOVEZ  (LOCLAB,T1),T1 
  
 GENCC14  LABEL 
          IFZ    (MNLNTH,EQ,0),GENCC20
          MINZ   MNLNTH,127,MNLNTH
          IFTHEN (USECU,EQ,0)      TEST FOR UNCOLLATED COMPARE
            GEN    CC$,MNLNTH,FWAPLUS,NBCPA,FWCPLUS,NBCPB,(VREGOF,CVREGA
,),CVREGB 
          ELSEZ 
            GEN    CU$,MNLNTH,FWAPLUS,NBCPA,FWCPLUS,NBCPB,(VREGOF,CVREGA
,)
          ENDIFZ
          IFTHEN (T1,EQ,0)   SET IF LOCAL LABEL DEFINED 
            MOVEZ  (LOCLAB,T1),T1  DEFINE LOCAL LABEL FOR FINAL TEST
          ENDIFZ
          GEN    NZ$,CVREGA,LOCALXX 
          SUBZ   LNTHA,MNLNTH,LNTHA 
          SUBZ   LNTHB,MNLNTH,LNTHB 
  
 GENCC16  LABEL 
          MULTZ  WRDOFF,10,NCA
          ADDZ   NCA,NBCPA,NBCPA   UP BCP W/ CURRENT OFFSET 
          ADDZ   MNLNTH,NBCPA,NCA 
          QUOTZ  NCA,10,WRDOFF
          REMZ   NCA,10,NBCPA 
  
 GENCC18  LABEL 
          MULTZ  WRDOFFC,10,NCA 
          ADDZ   NCA,NBCPB,NBCPB
          ADDZ   MNLNTH,NBCPB,NCA 
          QUOTZ  NCA,10,WRDOFFC 
          REMZ   NCA,10,NBCPB 
  
          MINZ   LNTHA,LNTHB,MNLNTH 
          MAXZ   LNTHA,LNTHB,TEMP 
          IFZ    (TEMP,GT,127),GENCC14
          BRANCH GENCC24
  
*      ONE GUY GONE - COMPARE W/ BLANKS 
  
 GENCC20  LABEL 
          IFZ    (LNTHB,EQ,0),GENCC22 
          IFTHEN (USECU,EQ,0)      TEST FOR UNCOLLATED COMPARE
            GEN    CC$,127,CPBLANK,0,FWCPLUS,NBCPB,(VREGOF,CVREGA),CVREG
,B
          ELSEZ 
            GEN    CU$,127,CPBLANK,0,FWCPLUS,NBCPB,(VREGOF,CVREGA)
          ENDIFZ
          IFTHEN (T1,EQ,0)   SET IF LOCAL LABEL DEFINED 
            MOVEZ  (LOCLAB,T1),T1  DEFINE LOCAL LABEL FOR FINAL TEST
          ENDIFZ
          GEN    NZ$,CVREGA,LOCALXX 
          MOVEZ  127,MNLNTH 
          SUBZ   LNTHB,127,LNTHB
          BRANCH GENCC18
  
 GENCC22  LABEL 
          IFTHEN (USECU,EQ,0)      TEST FOR UNCOLLATED COMPARE
            GEN    CC$,127,FWAPLUS,NBCPA,CPBLANK,0,(VREGOF,CVREGA),CVREG
,B
          ELSEZ 
            GEN    CU$,127,FWAPLUS,NBCPA,CPBLANK,0,(VREGOF,CVREGA)
          ENDIFZ
          IFTHEN (T1,EQ,0)   SET IF LOCAL LABEL DEFINED 
            MOVEZ  (LOCLAB,T1),T1  DEFINE LOCAL LABEL FOR FINAL TEST
          ENDIFZ
          GEN    NZ$,CVREGA,LOCALXX 
          MOVEZ  127,MNLNTH 
          SUBZ   LNTHA,127,LNTHA
          BRANCH GENCC16
  
 GENCC24  EJECT 
*      GENERATE EITHER LAST OR ONLY COMPARES - 127 OR LESS CHARS
*                REMAIN IN BOTH ITEMS 
  
 GENCC24  LABEL 
          IFZ    (MNLNTH,EQ,0),GENCC28
          IFZ    (LNTHA,EQ,LNTHB),GENCC26 
          IFTHEN (USECU,EQ,0)      TEST FOR UNCOLLATED COMPARE
            GEN    CC$,MNLNTH,FWAPLUS,NBCPA,FWCPLUS,NBCPB,(VREGOF,CVREGA
,),CVREGB 
          ELSEZ 
            GEN    CU$,MNLNTH,FWAPLUS,NBCPA,FWCPLUS,NBCPB,(VREGOF,CVREGA
,)
          ENDIFZ
          IFTHEN (T1,EQ,0)   SET IF LOCAL LABEL DEFINED 
            MOVEZ  (LOCLAB,T1),T1  DEFINE LOCAL LABEL FOR FINAL TEST
          ENDIFZ
          GEN    NZ$,CVREGA,LOCALXX 
          SUBZ   LNTHA,MNLNTH,LNTHA 
          SUBZ   LNTHB,MNLNTH,LNTHB 
          ADDZ   MNLNTH,NBCPA,NCA 
          QUOTZ  NCA,10,WRDOFF
          REMZ   NCA,10,NBCPA 
          ADDZ   MNLNTH,NBCPB,NCA 
          QUOTZ  NCA,10,WRDOFFC 
          REMZ   NCA,10,NBCPB 
          BRANCH GENCC28
  
 GENCC26  LABEL              EQUAL LENGTH ITEMS 
          IFTHEN (USECU,EQ,0)      TEST FOR UNCOLLATED COMPARE
            GEN    CC$,LNTHA,FWAPLUS,NBCPA,FWCPLUS,NBCPB,(VREGOF,CVREGA)
,,CVREGB
          ELSEZ 
            GEN    CU$,LNTHA,FWAPLUS,NBCPA,FWCPLUS,NBCPB,(VREGOF,CVREGA)
          ENDIFZ
          IFTHEN (T1,EQ,0)   SET IF LOCAL LABEL DEFINED 
            MOVEZ  (LOCLAB,T1),T1  DEFINE LOCAL LABEL FOR FINAL TEST
          ENDIFZ
          BRANCH GENCC30
  
 GENCC28  LABEL              A OR B EXHAUSTED 
          IFZ    (USECU,EQ,0),GENCC29  JP IF COLLATED COMPARE TO BE GEN 
          IFTHEN (LNTHA,EQ,0) 
            GEN    CU$,LNTHB,CPBLANK,0,FWCPLUS,NBCPB,(VREGOF,CVREGA)
          ELSEZ 
            GEN    CU$,LNTHA,FWAPLUS,NBCPA,CPBLANK,0,(VREGOF,CVREGA)
          ENDIFZ
          BRANCH GENCC30
 GENCC29  LABEL 
          IFTHEN (LNTHA,EQ,0) 
            GEN    CC$,LNTHB,CPBLANK,0,FWCPLUS,NBCPB,(VREGOF,CVREGA),CVR
,EGB
          ELSEZ 
            GEN    CC$,LNTHA,FWAPLUS,NBCPA,CPBLANK,0,(VREGOF,CVREGA),CVR
,EGB
          ENDIFZ
 GENCC30  LABEL 
          IFTHEN (T1,NE,0)   SEE IF LOCAL LABEL DEFINED 
            GEN    LABEL$,LOCALXX 
          ENDIFZ
          MOVEZ  0,DSPFLG 
          CALLZ  SPBRNCH
          RETURN
  
 IFI      ENDIF 
 IFNOT    EJECT 
* 
* 
**        IFNOT  -  DETERMINE IF WE HAVE A <NOT> CONDITION
* 
*                RETURNS - P1 = 1 IF TRUE, ELSE 0 
* 
* 
 IFNOT    EGO    4
          MOVEZ  (EQUALS,1),P1     SET TRUE 
  
          IFZ    ((GSCODEOF,CONREGA),EQ,GNOTALPH),IFNOTRTN
          IFZ    ((GSCODEOF,CONREGA),EQ,GNOTNUM),IFNOTRTN 
          IFZ    ((GSCODEOF,CONREGA),EQ,GNOTPOS),IFNOTRTN 
          IFZ    ((GSCODEOF,CONREGA),EQ,GNOTNEG),IFNOTRTN 
          IFZ    ((GSCODEOF,CONREGA),EQ,GNOTEQ),IFNOTRTN
          IFZ    ((GSCODEOF,CONREGA),EQ,GNOTGT),IFNOTRTN
          IFZ    ((GSCODEOF,CONREGA),EQ,GNOTLT),IFNOTRTN
          IFZ    ((GSCODEOF,CONREGA),EQ,GNOTSSW),IFNOTRTN 
* 
          MOVEZ  (EQUALS,0),P1     SET FALSE
* 
 IFNOTRTN LABEL 
  
          RETURN             SPLIT
* 
 INVTREL  EJECT 
*         INVTREL - INVERT RELATION IN CONREGA
*                THAT IS, IF A VS B WAS CHANGED TO IF B VS A - THEREFORE
*                EQUALS AND NOT EQUALS ARE THE SAME AND OTHERS CHANGE.
*                GCOMPARE WILL NOT GO THROUGH HERE. 
  
 INVTREL  EGO    4
          NOTE   INVTREL
          GOTOCASE  (GSCODEOF,CONREGA)
            CASE    GGREATER,INVTREL1 
            CASE    GLESS,INVTREL2
            CASE    GNOTGT,INVTREL3 
            CASE    GNOTLT,INVTREL4 
          ENDCASE 
          RETURN             NO CHANGE FOR = OR NOT = 
 INVTREL1 LABEL 
          MOVEZ  GLESS,(GSCODEOF,CONREGA) 
          RETURN
 INVTREL2 LABEL 
          MOVEZ  GGREATER,(GSCODEOF,CONREGA)
          RETURN
 INVTREL3 LABEL 
          MOVEZ  GNOTLT,(GSCODEOF,CONREGA)
          RETURN
 INVTREL4 LABEL 
          MOVEZ  GNOTGT,(GSCODEOF,CONREGA)
          RETURN
 LODSNUM  EJECT 
**        LODSNUM - LOAD SHORT NUMERICS 
* 
*                THIS ROUTINE GENERATES HIGHLY OPTIMIZED CODE 
*                            TO LOAD SHORT NUMERIC ITEMS (SIZE LESS THAN
*                            9) RIGHT JUSTIFIED WITHIN A REGISTER.
*                IT DOES NO MASKING OF THE LEFT END OF THE ITEM, LEAVING
*                            THAT UP TO THE CALLING ROUTINE.
* 
*         GENERATES:  
* 
*                CASE 1: ITEM DOES NOT SPAN WORD BOUNDARIES 
*         SAI    ITEM 
*         AXI    RJUST
* 
*                CASE 2: WORD SPANS WORD BOUNDARIES 
*         SAI    ITEM 
*         SAJ    AI+B1
*         MXK    60-NC2*6    NC2 = NR CHRS, 2ND WORD
*         LXI    NC2*6
*         LXJ    NC2*6
*         BXL    XI*XK
*         BXM    -XK*XJ 
*         BXN    XL+XM       COMPLETE 
* 
*                THIS ROUTINE EXPECTS REGK (CONREGK) TO CONTAIN 
*                            THE INPUT POINTER AND RETURNS THE
*                            VIRTUAL REGISTER NUMBER IN T1. 
* 
  
 LODSNUM  EGO    4
          NOTE   LODSNUM
          IFTHEN ((LEVELOF,CONREGK),EQ,TEMPLEVL)
            GEN    XMIT,(VREGOF,CVREGA),(TREGOF,CONREGK)
            BRANCH LODSNUM2 
          ENDIFZ
          GEN    SLRBPK,(VREGOF,CVREGA),,((FWA$OF,CONREGK)) 
          ADDZ   (BCPOF,CONREGK),(BYTLENOF,CONREGK),T1
          IFZ    (T1,GT,10),LODSNUM5   SPLIT WORD ITEM
  
          IFTHEN (T1,NE,10)        NOT ALREADY R. JUST. 
            SUBZ   10,T1,T1 
            MULTZ  T1,6,T1
            GEN    SHR,CVREGA,T1   RIGHT JUST ITEM
          ENDIFZ
  
 LODSNUM2 MOVEZ  CVREGA,T1
          RETURN
 LODSNUM5 SPACE  4
 LODSNUM5 LABEL 
          SUBZ   10,(BCPOF,CONREGK),T1
          SUBZ   (BYTLENOF,CONREGK),T1,T2 
          MULTZ  T2,6,T2
          SUBZ   60,T2,T1 
  
          GEN    SLRAPB,(VREGOF,CVREGB),CVREGA,CVB1 
          GEN    MASK,(VREGOF,CVREGC),T1
          GEN    SHL,CVREGA,T2
          GEN    SHL,CVREGB,T2
          GEN    LAND,(VREGOF,CVREGD),CVREGA,CVREGC 
          GEN    LIMP,(VREGOF,CVREGE),CVREGB,CVREGC 
          GEN    LOR,(VREGOF,CVREGA),CVREGD,CVREGE
          BRANCH LODSNUM2 
  
 REGSUB   EJECT 
* 
**        REGSUB - REGISTER COMPARISON OF 1 OR 2 WORD DISPLAY CODE
*                            ITEMS - CHECKS FOR EQUAL OR NOTEQ
* 
*                THE COMPARE CODE GENERATED DEPENDS UPON THE LENGTHS
*                            OF THE ITEMS BEING COMPARED. 
* 
*         SINGLE PRECISION (BOTH ITEMS LE 10 CHARS, ONE LT 10): 
*         IXI    XJ-XK
*         ZR     XI,TAG      IF EQ/TRUE  OR IF NEQ/FALSE
*           OR
*         NZ     XI,TAG      IF NE/TRUE  OR IF EQ/FALSE 
* 
* 
*         SINGLE PRECISION (10 CHARS EXACTLY)...JUMPS ARE SHOWN BELOW 
*         BXI    XJ-XK
* 
*         DOUBLE PRECISION (11 TO 20 CHARS):  
*         BXC    XD-XE
*         BXF    XG-XH
*         BXI    XC+XF
* 
* 
*                THE BRANCH CODE GENERATED DEPENDS UPON 
*                            (1)   THE VERB 
*                            (2)   THE BRANCH NODE
*                THERE ARE TWO POSSIBLE CASES:  
* 
*         CASE I (USED FOR IF EQ/TRUE + IF NEQ/FALSE) 
* 
*         NG     XI,LOCALXX        (SINCE 77....77B IS NOT ZERO IN THIS)
*         ZR     XI,TAG 
*LOCALXX  BSS    0
* 
* 
*         CASE 2 (USED FOR IF EQ/FALSE  + IF NEQ/TRUE)
* 
*         NZ     XI,TRUE
*         NG     XI,TRUE
* 
* 
*                WE EXPECT THE BRANCH SUBVERB IN CONREGD AND THE
*                            OPERANDS IN CONREGB + CONREGC
* 
* 
 REGSUB   EGO    4
          MAXZ   (BYTLENOF,CONREGB),(BYTLENOF,CONREGC),MXLNTH 
          MINZ   (BYTLENOF,CONREGB),(BYTLENOF,CONREGC),MNLNTH 
          MOVEZ  MNLNTH,CONREGL    SAVE MIN LENGTH
          MOVEZ  CONREGD,CONREGI
          MOVEZ  CONREGC,CONREGK
          MOVEZ  (EQUALS,CREG11),CONREGT
          CALLZ  ADNAT
          MOVEZ  (EQUALS,CREG11),CONREGC
  
*      SET UP FIRST DUMMY DNAT
  
          MOVEZ  ALPHNUM,(TYPEOF,CONREGC) 
          MOVEZ  MXLNTH,(BYTLENOF,CONREGC)
          MOVEZ  0,(BCPOF,CONREGC)
          CALLZ  MOVER
  
*      SAVE FIRST DNAT + SET UP SECOND
  
          MOVEZ  (BYTLENOF,CONREGC),MXLNTH
          MOVEZ  CONREGK,CONREGB
          MOVEZ  CONREGC,CONREGK
          MOVEZ  (EQUALS,CREG12),CONREGT
          CALLZ  ADNAT
          MOVEZ  (EQUALS,CREG12),CONREGC
          MOVEZ  ALPHNUM,(TYPEOF,CONREGC) 
          MOVEZ  MXLNTH,(BYTLENOF,CONREGC)
          MOVEZ  0,(BCPOF,CONREGC)
          CALLZ  MOVER
          MOVEZ  CONREGK,CONREGB
  
*      DETERMINE IF ONE WORD SPECIAL CASE 
  
          MOVEZ  (BYTLENOF,CONREGC),MXLNTH
          IFTHEN (MXLNTH,LE,MWDLNTH)
            MOVEZ  CONREGL,MNLNTH 
            IFZ    (MNLNTH,LT,MWDLNTH),RSCS3
          ENDIFZ
          NOTE   REGSUB 
  
*      BUILD SUBTRACT SEQUENCE
  
          IFTHEN (MXLNTH,LE,MWDLNTH)
            GEN    LXOR,(VREGOF,CVREGA),(TREGOF,CONREGB),(TREGOF,CONREGC
,)
          ELSEZ 
            GEN    LXOR,(VREGOF,CVREGB),(TREGOF,CONREGB),(TREGOF,CONREGC
,)
            GEN    LXOR,(VREGOF,CVREGC),(TREGP1OF,CONREGB),(TREGP1OF,CON
,REGC)
            GEN    LOR,(VREGOF,CVREGA),CVREGB,CVREGC
          ENDIFZ
          IFTHEN ((GSCODEOF,CONREGI),EQ,GTRUE)
            GOTOCASE  (GSCODEOF,CONREGA)
              CASE   GEQUAL,RSCS1 
              CASE   GNOTEQ,RSCS2 
            ENDCASE 
            ERROR  CONERR2         UNKNOWN CONDITION
          ELSEZ 
            GOTOCASE  (GSCODEOF,CONREGA)
              CASE   GEQUAL,RSCS2 
              CASE   GNOTEQ,RSCS1 
            ENDCASE 
            ERROR  CONERR2         UNKNOWN CONDITION
          ENDIFZ
 RSCS1    LABEL 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    NG$,CVREGA,LOCALXX 
          GEN    ZR$,CVREGA,((FWA$OF,CONREGI))
          GEN    LABEL$,LOCALXX 
          CALLZ  SUBDNAT
          CALLZ  SUBDNAT
          RETURN
          SPACE  4
 RSCS2    LABEL 
          GEN    NZ$,CVREGA,((FWA$OF,CONREGI))
          GEN    NG$,CVREGA,((FWA$OF,CONREGI))
          CALLZ  SUBDNAT
          CALLZ  SUBDNAT
          RETURN
          SPACE  4
 RSCS3    LABEL 
          NOTE   RSCS3
          GEN    ISUB,(VREGOF,CVREGA),(TREGOF,CONREGB),(TREGOF,CONREGC) 
          IFTHEN ((GSCODEOF,CONREGI),EQ,GTRUE)
            GOTOCASE  (GSCODEOF,CONREGA)
              CASE   GEQUAL,RSCS5 
              CASE   GNOTEQ,RSCS6 
            ENDCASE 
            ERROR  CONERR2         UNKNOWN CONDITION
          ELSEZ 
            GOTOCASE  (GSCODEOF,CONREGA)
              CASE   GEQUAL,RSCS6 
              CASE   GNOTEQ,RSCS5 
            ENDCASE 
            ERROR  CONERR2         UNKNOWN CONDITION
          ENDIFZ
  
  
 RSCS5    LABEL 
          GEN    ZR$,CVREGA,((FWA$OF,CONREGI))
          CALLZ  SUBDNAT
          CALLZ  SUBDNAT
          RETURN
          SPACE  4
 RSCS6    LABEL 
          GEN    NZ$,CVREGA,((FWA$OF,CONREGI))
          CALLZ  SUBDNAT
          CALLZ  SUBDNAT
          RETURN
  
 SPBRNCH  EJECT 
* 
**        SPBRNCH - BUILD BRANCHES FOR S.P. COMPARES (AND D.P. COMP-2)
* 
*                THE CODE GENERATED DEPENDS UPON
*                            (1)   WHICH VERB WE HAVE 
*                            (2)   WHETHER THE BRANCH NODE IS TO
*                                  TRUE CODE OR FALSE CODE
* 
*                THERE ARE SIX POSSIBLE CODE SEQUENCES GENERATED: 
*                            [TAG IS USED TO REFER TO THE BRANCH TAG] 
* 
*         CASE 1 (USED FOR IF EQ/TRUE + IF NOT EQ/FALSE)
* 
*         ZR     XI,TAG 
* 
* 
*         CASE 2 (USED FOR IF EQ/FALSE + IF NOT EQ/TRUE)
* 
*         NZ     XI,TAG 
* 
* 
*         CASE 3 (USED FOR IF GR/TRUE + IF NOT GR/FALSE)
* 
*         ZR     XI,LOCALXX 
*         PL     XI,TAG 
*LOCALXX  BSS    0
* 
* 
*         CASE4 (USED FOR IF GR/FALSE + IF NGR/TRUE)
* 
*         ZR     XI,TAG 
*         NG     XI,TAG 
* 
* 
*         CASE 5 (USED FOR IF LT/TRUE + IF NLT/FALSE) 
* 
*         NG     XI,TAG 
* 
* 
*         CASE 6 (USED FOR IF LT/FALSE + IF NLT/TRUE) 
* 
*         PL     XI,TAG 
* 
* 
*         FOR COMPARE VERBS:  
* 
*         ZR     XI,LOCALXX 
*         PL     XI,TAGI
*         NG     XI,TAGE
*LOCALXX  BSS    0
* 
* 
*                THIS ROUTINE EXPECTS CONREGI TO CONTAIN THE BRANCH 
*                            SUBVERB AND CVREGA TO CONTAIN THE
*                            REGISTER ASSIGNED TO "I" 
* 
*                IF THE FLAG -DSPFLG- IS NON-ZERO, WE MUST USE
*                            (TREGOF,CONREGD) FOR ALL -PL- OR -NG-
*                            TESTS, SINCE THE DEBIAS SUBTRACT WILL
*                            HAVE DESTROYED THE SIGN INFO.
* 
* 
  
 SPBRNCH  EGO    4
          NOTE   SPBRNCH
          IFZ    ((GSCODEOF,CONREGA),EQ,GCOMPARE),SPCOMP
          IFTHEN ((GSCODEOF,CONREGI),EQ,GTRUE)
            GOTOCASE  (GSCODEOF,CONREGA)
              CASE   GEQUAL,SPCS1 
              CASE   GGREATER,SPCS3 
              CASE   GLESS,SPCS5
              CASE   GNOTEQ,SPCS2 
              CASE   GNOTGT,SPCS4 
              CASE   GNOTLT,SPCS6 
            ENDCASE 
            ERROR  CONERR2         UNKNOWN CONDITION
          ELSEZ 
            GOTOCASE  (GSCODEOF,CONREGA)
              CASE   GEQUAL,SPCS2 
              CASE   GGREATER,SPCS4 
              CASE   GLESS,SPCS6
              CASE   GNOTEQ,SPCS1 
              CASE   GNOTGT,SPCS3 
              CASE   GNOTLT,SPCS5 
            ENDCASE 
            ERROR  CONERR2
          ENDIFZ
  
*      CASE1
  
 SPCS1    LABEL 
          GEN    ZR$,CVREGA,((FWA$OF,CONREGI))
          RETURN
 SPCS2    SPACE  4
*      CASE 2 
  
 SPCS2    LABEL 
          GEN    NZ$,CVREGA,((FWA$OF,CONREGI))
          RETURN
 SPCS3    SPACE  4
*      CASE 3 
  
 SPCS3    LABEL 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    ZR$,CVREGA,LOCALXX 
          IFTHEN (DSPFLG,EQ,0)
            GEN    PL$,CVREGA,((FWA$OF,CONREGI))
          ELSEZ 
            GEN    PL$,(TREGOF,CONREGD),((FWA$OF,CONREGI))
          ENDIFZ
          GEN    LABEL$,LOCALXX 
          RETURN
 SPCS4    SPACE  4
*      CASE 4 
  
 SPCS4    LABEL 
          GEN    ZR$,CVREGA,((FWA$OF,CONREGI))
          IFTHEN (DSPFLG,EQ,0)
            GEN    NG$,CVREGA,((FWA$OF,CONREGI))
          ELSEZ 
            GEN    NG$,(TREGOF,CONREGD),((FWA$OF,CONREGI))
          ENDIFZ
          RETURN
 SPCS5    SPACE  4
*      CASE 5 
  
 SPCS5    LABEL 
          IFTHEN (DSPFLG,EQ,0)
            GEN    NG$,CVREGA,((FWA$OF,CONREGI))
          ELSEZ 
            GEN    NG$,(TREGOF,CONREGD),((FWA$OF,CONREGI))
          ENDIFZ
          RETURN
 SPCS6    SPACE  4
*      CASE 6 
  
 SPCS6    LABEL 
          IFTHEN (DSPFLG,EQ,0)
            GEN    PL$,CVREGA,((FWA$OF,CONREGI))
          ELSEZ 
            GEN    PL$,(TREGOF,CONREGD),((FWA$OF,CONREGI))
          ENDIFZ
          RETURN
 SPCOMP   SPACE  4
*      COMPARE VERB BRANCHING 
  
 SPCOMP   LABEL 
          MOVEZ  (LOCLAB,LOCXX),LOCXX 
          GEN    ZR$,CVREGA,LOCALXX 
          IFTHEN (DSPFLG,EQ,0)
            GEN    PL$,CVREGA,((FWA$OF,CONREGI))
            GEN    NG$,CVREGA,((FWA$OF,CONREGE))
          ELSEZ 
            GEN    PL$,(TREGOF,CONREGD),((FWA$OF,CONREGI))
            GEN    NG$,(TREGOF,CONREGD),((FWA$OF,CONREGE))
          ENDIFZ
          GEN    LABEL$,LOCALXX 
          RETURN
  
  
          END 
