*DECK             SYMBIT
USETEXT   TSOURCE 
USETEXT   TCEXECQ 
USETEXT   TSYMCNS 
USETEXT   TCEXEC
USETEXT   TCOM37Q 
USETEXT   TCOM78Q 
USETEXT   TC7DECS 
PROC SYMBIT((I));            # SYMPL BIT FUNCTION  #
BEGIN 
  
  
  
  
*CALL COMEX 
  
  
  
  
    ITEM I;  # FUNI TRIAD INDEX  (L M FLST N FLST FUNI)#
    ITEM J,K,L,M,N,O,P; 
    ITEM TR1,TR2,TR3,TR4,TR5,TR6,TR7,TR8,TR9;                            JANDRE 
    ITEM TR10 R;                                                         JANDRE 
    XREF PROC ICFGEN; 
    XREF PROC ICFGNR; 
    XREF FUNC INCRMT;                                                    JANDRE 
    XREF FUNC KFIND;
    XREF PROC LOAD; 
      XREF PROC SAVESV; 
      XREF PROC KGT00;
    XDEF PROC MOVET;
    XREF FUNC MSKGEN; 
    XREF PROC MULV6;                                                     JANDRE 
    XREF FUNC PSICON; 
    XDEF PROC SLOD; 
    XDEF PROC SLODL;
    J=LOPD[I]; #1ST FLST TRIAD# 
    K=LOPD[J]; #2ND FLST TRIAD# 
    L=LOPD[K]; #FIRST BIT TRIAD#
    M=ROPD[K]; #NUMBER OF BITS TRIAD# 
    N=ROPD[J]; #OBJECT TRIAD# 
      IF AC$S[N] EQ S"GR" THEN
              BEGIN 
              SAVESV(I);
              IF MEMR[M] LS 0 AND NOT SAVD[M] THEN
                  BEGIN 
                  ICFGEN(QICFOP"SAVE",0,MEMR[M]); 
                  SAVD[M] = TRUE; 
                  MEMR[M] = ICFPTR; 
                  END 
               KGT00(I);
          IF ENBT[I] - (ENBT[I]/60) * 60 NQ 0 THEN
              # N.B. SYMSG IS LEFT JUSTIFIED - BIT FUN IS RIGTH RUST.#
              ICFGEN( QICFOP"LSHC" , ICFPTR, ENBT[I] -(ENBT[I]/60) *60);
          IF NOT KFLG[M] THEN 
          ICFGEN(QICFOP"LSHV",MEMR[M],ICFPTR);
              MEMR[I]=ICFPTR; 
          IF SAVD[M] THEN 
          ICFGEN(QICFOP"DEAD",MEMR[M],0); 
              RETURN; 
               END
    VFLG[N]=S"NUMB";
    $TST[N]=F;
    $IGN[N]=F;
    IF KFLG[L] AND KFLG[M] THEN 
         BEGIN #DEGENERATE CASE#
         EFBT[N]=KONS[L]+EFBT[N]; 
         ENBT[N]=KONS[M]; 
         IF ENBT[N] LS 60 THEN AC$S[N]=S"LS"; 
         SFLG[N]=T; #FORCES EXTRACT#
         MOVET(N,I); #MOVES OBJECT TO FUNI# 
         LOAD(I); 
         RETURN;
         END
    SLODL(N); #LOAD OBJECT TO WITHIN A FULL-WORD# 
    IF KFLG[M] THEN 
         BEGIN #NUMBER OF BITS IS CONSTANT# 
         ENBT[N]=KONS[M]; 
         IF EFBT[N] NQ 0 THEN 
              BEGIN 
              ICFGEN(QICFOP"LSHC",MEMR[N],EFBT[N]); 
              MEMR[N]=ICFPTR; 
              END 
         ICFGEN(QICFOP"LSHV",MEMR[L],MEMR[N]);
         ICFGNR(QICFOP"LAND",MSKGEN(ENBT[N]),-1);                        JANDRE 
         ICFGNR(QICFOP"LSHC",-1,ENBT[N]); 
SY00:    MEMR[N]=ICFPTR;
         MOVET(N,I);
         RETURN;
         END #CONSTANT N# 
    IF KFLG[L] THEN 
         BEGIN #FIRST BIT IS CONSTANT#
         ICFGEN(QICFOP"ADSC",MEMR[M],PMINUS1);                           JANDRE 
         ICFGEN(QICFOP"RSHV",ICFPTR,MASK1);                              JANDRE 
         P=ICFPTR;
         O=KONS[L]+EFBT[N]; 
         IF O NQ 0 THEN 
              BEGIN 
              ICFGEN(QICFOP"LSHC",MEMR[N],O); 
              MEMR[N]=ICFPTR; 
              END 
         ICFGEN(QICFOP"LAND",P,MEMR[N]);
         ICFGEN(QICFOP"LSHV",MEMR[M],ICFPTR); 
         GOTO SY00; 
         END #CONSTANT F# 
    #BOTH FIRST BIT AND NUMBER OF BITS IS VARIABLE# 
    IF EFBT[N] NQ 0 THEN
         BEGIN
         ICFGEN(QICFOP"LSHC",MEMR[N],EFBT[N]);
         MEMR[N]=ICFPTR;
         END
    ICFGEN(QICFOP"ADSC",MEMR[M],PMINUS1);                                JANDRE 
    ICFGEN(QICFOP"LSHV",MEMR[L],MEMR[N]); 
    ICFGNR(QICFOP"RSHV",-2,MASK1);                                       JANDRE 
    ICFGNR(QICFOP"LAND",-2,-1); 
    ICFGEN(QICFOP"LSHV",MEMR[M],ICFPTR);
    GOTO SY00;
CONTROL EJECT;
PROC SLOD((I));    # SUBS-LOAD  I=TRIAD POINTER # 
    BEGIN 
    ITEM I,J,K; 
    J=MEMR[I];
    IF NOT BWOR[I] THEN # REGULAR CASE #                                 JANDRE 
    BEGIN                                                                JANDRE 
    IF OFFS[I] NQ 0 THEN
         BEGIN
         ICFGEN(QICFOP"OFFS",J,OFFS[I]);
         MEMR[I]=ICFPTR;
         END
    IF INDX[I] NQ 0 THEN
         BEGIN
         ICFGEN(QICFOP"SUBS",MEMR[I],INDX[I]);
         MEMR[I]=ICFPTR;
         END
    RETURN;                                                              JANDRE 
    END # REGULAR CASE #                                                 JANDRE 
                                                                         JANDRE 
    # ELSE GENERATE IN-LINE FETCH OF C<F,N>LONG WHEN NO-WORD-CROSSING  # JANDRE 
    #                                    F=EXPRESSION, N=CONSTANT      # JANDRE 
    $BEGIN
    # NOT YET DEBUGGED. BWOR IS NOT SET TO TRUE- SEE PHASBS.FBYT #       JANDRE 
    TR1=POTE[I];     # SET BY PHASBS TO 1ST FLST TRIAD #                 JANDRE 
    TR2=LOPD[TR1];   #FBDX TRUAD #                                       JANDRE 
    TR4=KONS[ROPD[TR1]]; # NBDX VALUE #                                  JANDRE 
    TR3=POTE[ROPD[TR1]]; # IN CASE OF C<EXP+TR3,TR4> #                   JANDRE 
    TR5=MEMR[TR2];       # ICFPTR TO 1ST BYTE #                          JANDRE 
    TR6=EFBY[I];         # 1ST BYTE OF ITEM #                            JANDRE 
    IF TR6 NQ 0 THEN                                                     JANDRE 
         BEGIN # DYNAMIC 1ST BYTE OFFSET #                               JANDRE 
         ICFGEN(QICFOP"ADSC",TR5,TR6);      # EXP+EFBY #                 JANDRE 
         TR5=ICFPTR;                                                     JANDRE 
         END                                                             JANDRE 
    IF TR3 NQ 0 THEN                                                     JANDRE 
         BEGIN # C<E+TR3> #                                              JANDRE 
         ICFGEN(QICFOP"ADSC",TR5,TR3);   # EXP+TR3+EFBY #                JANDRE 
         TR5=ICFPTR;                                                     JANDRE 
         END                                                             JANDRE 
    ICFGEN(QICFOP"PACK",TR5,0);         TR9=ICFPTR;                      JANDRE 
    ICFGNR(QICFOP"FMUL",-1,PSICON(TENTH));   # *0.1 #                    JANDRE 
    ICFGNR(QICFOP"BXND",-1,0);                                           JANDRE 
    TR7=ICFPTR;                                # TR7:-(EXP+TR3+TR6)/10#  JANDRE 
    MULV6(TR7);                                                          JANDRE 
    ICFGEN(QICFOP"ISUB",ICFPTR,TR7);                                     JANDRE 
    MEMR[TR2]=ICFPTR;        # NEW FIRST BYTE #                          JANDRE 
    J=MEMR[I];                                                           JANDRE 
    TR8=J;                                                               JANDRE 
    K=OFFS[I];                                                           JANDRE 
    IF K NQ 0 THEN                                                       JANDRE 
         BEGIN                                                           JANDRE 
         ICFGEN(QICFOP"OFFS",J,K);                                       JANDRE 
         J=ICFPTR;                                                       JANDRE 
         END                                                             JANDRE 
    K=INDX[I];                                                           JANDRE 
    IF K NQ 0 THEN                                                       JANDRE 
         BEGIN                                                           JANDRE 
         ICFGEN(QICFOP"SUBS",J,K);                                       JANDRE 
         J=ICFPTR;                                                       JANDRE 
         END                                                             JANDRE 
    ICFGEN(QICFOP"LOC",J,0);                                             JANDRE 
    K=INCRMT(TR8);                                                       JANDRE 
    IF K NQ 1 THEN                                                       JANDRE 
         BEGIN # PARALLEL, INCREMENT=K #                                 JANDRE 
         TR10=K;   # TRQNSFORM TO REAL #                                 JANDRE 
         ICFGEN(QICFOP"FMUL",TR9,PSICON(TR10));                          JANDRE 
         ICFGNR(QICFOP"UNPB",-1,0);                                      JANDRE 
         ICFGNR(QICFOP"SELB",-1,0);                                      JANDRE 
         ICFGNR(QICFOP"LSHV",-1,-2);                                     JANDRE 
         TR7=ICFPTR;                                                     JANDRE 
         END                                                             JANDRE 
    ICFGEN(QICFOP"IADD",TR3,TR7);                                        JANDRE 
    MEMR[I]=ICFPTR;                                                      JANDRE 
    # END C<EXP,CONS> #                                                  JANDRE 
    $END
                                                                         JANDRE 
    END 
CONTROL EJECT;
PROC SLODL((I));   # SLOD AND LOAD  I=TRIAD POINTER#
    BEGIN 
    ITEM I; 
    SLOD(I);
    ICFGEN(QICFOP"LOAD",MEMR[I],0); 
    MEMR[I]=ICFPTR; 
    END 
CONTROL EJECT;
PROC MOVET((I),(J));  # MOVE TRIAD I INTO TRIAD J # 
    BEGIN #PRESERVING B NXOP LINK AND SDFG# 
    ITEM I,J; 
    NXOP[I]=NXOP[J];
    SDFG[I]=SDFG[J];
    RLTL[I]=RLTL[J];
    KLSS[I]=KLSS[J];
    OOAR[J]=OOAR[I];
    OOAR[J+1]=OOAR[I+1];
    OOAR[J+2]=OOAR[I+2];
    OOAR[J+3]=OOAR[I+3];
    OOAR[J+4]=OOAR[I+4];                                                 JANDRE 
    END 
END 
TERM
