*DECK  GETSEQ                                                            GETSEQ 
          PROC  GETSEQ;                                                  GETSEQ 
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   GETSEQ - DETERMINES NEXT INSTRUCTION SEQUENCE FOR OPTIMIZATION    #
 #            AND REGISTER ASSIGNMENT                                  #
 #                                                                     #
 #   GIVEN - STATUS OF LAST ATTEMPT TO PROCESS SEQUENCE AND LIMITS OF  #
 #           LAST SEQUENCE IN INSTRUCTION LIST                         #
 #                                                                     #
 #   DOES - SETS LIMITS OF NEXT SEQUENCE IN INSTRUCTION LIST TO BE     #
 #          PROCESSED. CALLS READSEQ TO GET A NEW SEQUENCE FROM        #
 #           INSTRUCTION INPUT FILE IF ALL INSTRUCTIONS IN LIST HAVE   #
 #           BEEN PROCESSED                                            #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
  
*CALL ASMINST                                                            GETSEQ 
*CALL ASMCOMM                                                            GETSEQ 
*CALL TABLETYP
*CALL VREGCOM 
*CALL AREGS 
          DEF  FULLSEQ #1#; 
*CALL SEQCOM
*CALL RALINE
                                                                         GETSEQ 
          DEF  FINDR(A,B)  #A#; 
          XDEF  PROC  PRESCAN;
          XDEF  PROC  SLOCKPR;
          XREF                                                           GETSEQ 
              BEGIN                                                      GETSEQ 
              PROC  ASMABT; 
              PROC CMM$GLV; 
              PROC  READSEQ;                                             GETSEQ 
              END                                                        GETSEQ 
          XREF                                                           COBASM 
              ARRAY  RESREG [0:0];                                       COBASM 
                  ITEM                                                   COBASM 
                      RESASM   B(0, 0, 1), #ASEMBLER SCRATCH REGISTER  # COBASM 
                      RESMACH  B(0, 1, 1), #MACHINE CONSTANT REGISTER  # COBASM 
                      RESNUM   U(0,57, 3), #REGISTER NUMBER            # COBASM 
                      RESTYPE  S:REGTYPE(0,54,3),  #REGISTER TYPE      # COBASM 
                      RESVAL   B(0, 2, 1), #REGISTER HAS CONSTANT VALUE# COBASM 
                      RVALUE;              #VALUE                      # COBASM 
          ITEM  DFLAG  B; 
          ITEM  I;
          ITEM  II; 
          ITEM  INC;
          ITEM  J;
          ITEM  K;
          ITEM  OPC  S:OPNAMES; 
          XREF  ITEM  NRESREG;
                                                                         GETSEQ 
          CONTROL EJECT;                                                 SCANSEQ
          PROC  DEFREG((K),(TYPE)); 
          ITEM  K;
          ITEM  TYPE  S:REGTYPE;
          ITEM  RDFLAG  B;
                  BEGIN                                                  SCANSEQ
                  $BEGIN
                  IF  NOT DEFINED[K] AND STORE[OPC] 
                  THEN  ASMABT("REFERENCE TO UNDEFINED REGISTER",32); 
                  IF  K EQ 0 AND (TYPE NQ S"TYPEB" OR OPC NQ S"NORM") 
                  THEN  ASMABT("ZERO VIRTUAL REGISTER NUMBER",28);
                  $END
                  IF  DEFINED[K]
                  THEN
                      BEGIN 
                      RDFLAG = FALSE; 
                      IF  TYPE NQ S"TYPEA"
                      THEN
                          BEGIN 
                          IF  TYPE NQ S"TYPEB" OR OPC NQ S"NORM"
                              OR K NQ 0 
                          THEN
                              BEGIN 
                              REDEF[K] = TRUE;
                              RDFLAG = TRUE;
                              END 
                          END 
                      ELSE
                          BEGIN 
                          IF  LOADI[OPC]
                          THEN
                              IF  LOADED[K] 
                                  THEN
                                      BEGIN 
                                      REDEFA[K] = TRUE; 
                                      RDFLAG = TRUE;
                                      END 
                                  ELSE
                                      BEGIN 
                                      REDEF[K] = TRUE;
                                      RDFLAG = TRUE;
                                      END 
                          IF  STORE[OPC] AND STORED[K]
                              THEN
                              BEGIN 
                              REDEFA[K] = TRUE; 
                              RDFLAG = TRUE;
                              END 
                          IF  NOT (LOADI[OPC] OR STORE[OPC])
                          THEN
                              BEGIN 
                              REDEFA[K] = TRUE; 
                              RDFLAG = TRUE;
                              END 
                          END 
                      $BEGIN
                      IF  RDFLAG AND NOT RHOLD[K] AND LOCKREG[K] EQ 0 
                      THEN  ASMABT("ILLEGAL REGISTER REDEFINITION",29); 
                      $END
                      END 
                  DEFINED[K] = TRUE;
                  END                                                    SCANSEQ
          CONTROL  EJECT; 
          PROC  SLOCKPR(VR,TYPE); 
          ITEM  J;
          ITEM  TYPE  S:REGTYPE;
          ITEM  VR; 
          BEGIN 
          LOCKSIZE = LOCKSIZE + 1;
          J = FIRSTLOCK[AREG[VR] + REGOFF[TYPE]]; 
          IF  J EQ 0
          THEN
              FIRSTLOCK[AREG[VR] + REGOFF[TYPE]] = LOCKSIZE;
          ELSE
              BEGIN 
              DOWHILE  LOCKLINK[J] NQ 0  DO J = LOCKLINK[J];
              LOCKLINK[J] = LOCKSIZE; 
              END 
          LOCKINST[LOCKSIZE] = ENDSEQ;
          LOCKLINK[LOCKSIZE] = 0; 
          IF  LOCKSIZE EQ LOCKLIM 
          THEN
              BEGIN 
              CMM$GLV (LOCKLIST, 50);   #EXTEND TABLE#
              LOCKLIM = LOCKLIM + 50; 
              END 
          RETURN; 
          END 
          CONTROL  EJECT; 
       PROC  PRESCAN; 
          BEGIN 
              II = ENDSEQ;
              OPC = OPCODE[II]; 
          IF  REGINST[OPC] NQ 0 
          THEN
          BEGIN 
              IF  OPC EQ S"RDEF"
              THEN
                  BEGIN 
                  J = IREG[II]; 
                  LOCKREG[J] = JREG[II];
                  IF  LOCKB[J]   THEN SLOCKPR(J,REGTYPE"TYPEB") ; 
                  ELSE  IF LOCKX[J] OR (LOCKA[J] AND AREG[J] NQ 0)
                      THEN  SLOCKPR(J,REGTYPE"TYPEX");
                  END 
              $BEGIN
              IF  DEFI[OPC] 
              THEN
                  BEGIN 
                  J = IREG[II]; 
                  DEFREG(J,TYPEI[OPC]); 
                  END 
              IF  DEFJ[OPC] 
              THEN
                  BEGIN 
                  J = JREG[II]; 
                  DEFREG(J,TYPEJ[OPC]); 
                  END 
              $END
              IF  USEI[OPC] 
              THEN
                  BEGIN 
                  $BEGIN
                  IF  NOT DEFINED[IREG[II]] 
                  THEN  ASMABT("REFERENCE TO UNDEFINED REGISTER",32); 
                  IF  IREG[II] EQ 0 AND TYPEI[OPC] NQ S"TYPEB"
                  THEN  ASMABT("ZERO VIRTUAL REGISTER NUMBER",28);
                  $END
                  K = IREG[II]; 
                  LASTUSE[K] = II;
                  USES[K] = USES[K] + 1;
                  END 
              IF  USEJ[OPC] 
              THEN
                 BEGIN
                  $BEGIN
                  IF  NOT DEFINED[JREG[II]] 
                 THEN  ASMABT("REFERENCE TO UNDEFINED REGISTER",32);
                  IF  JREG[II] EQ 0 AND TYPEJ[OPC] NQ S"TYPEB"
                  THEN  ASMABT("ZERO VIRTUAL REGISTER NUMBER",28);
                  $END
                  K = JREG[II]; 
                  LASTUSE[K] = II;
                  IF  TYPEJ[OPC] EQ S"TYPEA"
                  THEN  USESA[K] = USESA[K] + 1;
                  ELSE  USES[K] = USES[K] + 1;
                 END
              IF  USEK[OPC] 
              THEN
                  BEGIN 
                  $BEGIN
                  IF  NOT DEFINED[KREG[II]] 
                  THEN  ASMABT("REFERENCE TO UNDEFINED REGISTER",32); 
                  IF  KREG[II] EQ 0 AND TYPEK[OPC] NQ S"TYPEB"
                  THEN  ASMABT("ZERO VIRTUAL REGISTER NUMBER",28);
                  $END
                  K = KREG[II]; 
                  LASTUSE[K] = II;
                  USES[K] = USES[K] + 1;
                  END 
              IF  OPC EQ S"RFREE"  THEN  LASTUSE[IREG[II]] = II;
              IF  STORE[OPC]
              THEN
                  BEGIN 
                  K = IREG[II]; 
                  LASTUSE[K] = II;
                  STORED[K] = TRUE; 
                  USES[K] = USES[K] + 1;
                  END 
              IF LOADI[OPC]  THEN  LOADED[IREG[II]] = TRUE; 
              IF  OPC EQ S"SHL" OR OPC EQ S"SHR"
              THEN  REDEF[FINDR(IREG[II],DFLAG)] = TRUE;
          END 
          END 
          CONTROL  EJECT; 
          BEGIN                                                          GETSEQ 
          FOR  I = 0 STEP 1 UNTIL 23 DO AREGW[I] = 0; 
 #        PROCESS RESERVED REGISTERS                                   # COBASM 
          J = 0;                                                         COBASM 
          FOR  I = 0 STEP 1 UNTIL NRESREG-1 DO                           COBASM 
              BEGIN                                                      COBASM 
              VREG1[I] = 0;                                              COBASM 
              VREG2[I] = 0;                                              COBASM 
              AREG[I] = RESNUM[J];                                       COBASM 
              VREGF[I] = I;                                              COBASM 
              ASSIGND[I] = TRUE;                                         COBASM 
              DEFINED[I] = TRUE;
              RESERVED[REGOFF[RESTYPE[J] ] + RESNUM[J]] = TRUE;          COBASM 
              IF   RESASM[J] THEN  ASMREG = RESNUM[J];                   COBASM 
              IF  RESVAL[J] THEN  J = J + 2; ELSE J = J + 1;             COBASM 
              END                                                        COBASM 
          FIRSTLINE = LINE; 
          LOCKSIZE = 0; 
          READSEQ;
          RETURN;                                                        GETSEQ 
          END                                                            GETSEQ 
          TERM                                                           GETSEQ 
