*DECK COBASM                                                             COBASM 
USETEXT CCTTEXT 
          PROC COBASM;
  
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
 #                                                                     #
 #   COBASM - CONTROL ROUTINE FOR PASS ONE OF ASSEMBLER                #
 #                                                                     #
 #   GIVEN - INSTRUCTION INPUT FILE                                    #
 #                                                                     #
 #   DOES  - CREATES INSTRUCTION OUTPUT FILE WITH PSEUDO INSTRUCTIONS  #
 #           EXPANDED AND MACHINE REGISTERS ASSIGNED AND ASSIGNS       #
 #           ADDRESSES                                                 #
 #                                                                     #
 # * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * #
          CONTROL  PRESET;                                               COBASM 
*CALL ASMINST                                                            COBASM 
*CALL AREGS                                                              COBASM 
*CALL VREGCOM                                                            COBASM 
*CALL USETAB
*CALL TABLETYP
          DEF  FULLSEQ  #0#;
*CALL SEQCOM
*CALL ASMCOMM                                                            COBASM 
*CALL RALINE
          ARRAY  BLDINST[0:8];
              ITEM
                  BLDWRD  DTEXT,
                  CONS    DCONS,
                  CONST   DCONST, 
                  COUNT   DCOUNT, 
                  INDEX   DINDEX, 
                  MOD     DMOD, 
                  OPC     DOPC, 
                  TABLE   DTABLE; 
          ITEM  SEGMENT B;
                                                                         COBASM 
          XREF                                                           COBASM 
              BEGIN                                                      COBASM 
              PROC  ASM2; 
              PROC  CLOBIN; 
              PROC  CLOSINS;
              FUNC CMI$ALV; 
              FUNC CMM$AGR; 
              FUNC CMM$ALV; 
              PROC  CMM$FGR;
              PROC  CMI$FRV;
              FUNC  DEFBLOCK; 
              PROC  FLUSHWS;
              PROC  GETSEQ;                                              COBASM 
              ITEM  GROUP1FLAG; 
              PROC INITIN;
              PROC  INITOUT;                                             COBASM 
              PROC  INITRD;                                              COBASM 
              PROC  INSTGEN;                                             COBASM 
              PROC  INSTOUT;
              PROC  LABELPR;
              FUNC  NEXTLAB;
              PROC  OPENINS;
              PROC  OPNBIN; 
              PROC  RTNINST;
              END                                                        COBASM 
                                                                         COBASM 
          XREF  ITEM  INSTEOF B;
          XREF  ITEM  MAXLAB; 
          XREF  ITEM  USEID;
          CONTROL  EJECT; 
          PROC  ASMEND; 
          ITEM  COMBLK; 
          ITEM  COMLIST;
          ITEM  COMCOUNT; 
          ITEM  NBLK; 
          ITEM  J;
          ITEM  LOCN; 
          BEGIN 
 #   COMPLETE LAST BLOCK                                               #
          USEORG[BLOCK] = ORG;
          USEPOS[BLOCK] = POS;
 #     APPEND ZERO WORD TERMINATOR TO ADDRESS SUBSTITUTION LIST        #
          IF  USEORG[ADSUBBLK] NQ 0 
          THEN
              BEGIN 
              OPC[0] = S"USE$"; 
              TABLE[0] = S"USETAB$";
              INDEX[0] = ADSUBBLK;
              CONS[0] = 0;
              INSTOUT(LOC(BLDINST),1);
              OPC[0] = S"DATA$";
              COUNT[0] = 1; 
              BLDWRD[1] = 0;
              INSTOUT(LOC(BLDINST),2);
              USEORG[ADSUBBLK]=  USEORG[ADSUBBLK] + 1;
              END 
 #   ALLOCATE ATEMPS                                                   #
          J = DEFBLOCK("ATEMPS",FALSE,FALSE); 
          OPC[0] = S"USE$"; 
          TABLE[0] = S"USETAB$";
          INDEX[0] = J; 
          CONS[0] = 0;
          INSTOUT(LOC(BLDINST),1);
          OPC[0] = S"BSS$"; 
          CONST[0] = NATEMPS; 
          COUNT[0] = 0; 
          INSTOUT(LOC(BLDINST),1);
          USEORG[J] = NATEMPS;
          USEPOS[J] = WORDSIZE; 
          IF CCTTDF AND (CCTMAINSUB OR NOT CCTSUBPROGR) AND NOT SEGMENT 
          THEN
              BEGIN 
              COMCOUNT = 0; 
              NBLK = BLOCKCNT;
              FOR  J = 1 STEP 1 UNTIL NBLK DO 
                  BEGIN 
                  IF  GLOBAL[J] 
                  THEN
                      BEGIN 
                      IF  COMCOUNT EQ 0 
                      THEN
                          BEGIN 
                          COMBLK = DEFBLOCK("C.CMBLK",TRUE,FALSE);
                          COMLIST= DEFBLOCK("COMLIST",FALSE,FALSE); 
                          OPC[0] = S"USE$"; 
                          TABLE[0] = S"USETAB$";
                          INDEX[0] = COMLIST; 
                          CONS[0] = 0;
                          INSTOUT(LOC(BLDINST),1);
                          END 
                      COMCOUNT = COMCOUNT + 1;
                      OPC[0] = S"VFD$"; 
                      COUNT[0] = 8; 
                      OPC[1] = 1; 
                      TABLE[1] = S"NULL"; 
                      CONS[1] = 0;
                      BLDWRD[2] = 1;
                      OPC[3] = 23;
                      TABLE[3] = S"NULL"; 
                      CONS[3] = 0;
                      BLDWRD[4] = J;
                      OPC[5] = 18;
                      TABLE[5] = S"NULL"; 
                      CONS[5] = 0;
                      BLDWRD[6] = USEORG[J];
                      IF  USEPOS[J] NQ WORDSIZE 
                      THEN  BLDWRD[6] = BLDWRD[6] + 1;
                      OPC[7] = 18;
                      TABLE[7] = S"USEORG$";
                      INDEX[7] = J; 
                      CONS[7] = 0;
                      BLDWRD[8] = 0;
                      INSTOUT(LOC(BLDINST),9);
              END 
                  END 
              IF  COMCOUNT NQ 0 
              THEN
                  BEGIN 
                  OPC[0] = S"USE$"; 
                  TABLE[0] = S"USETAB$";
                  INDEX[0] = COMBLK;
                  CONS[0] = 0;
                  INSTOUT(LOC(BLDINST),1);
                  OPC[0] = S"VFD$"; 
                  COUNT[0] = 4; 
                  OPC[1] = 30;
                  TABLE[1] = S"NULL"; 
                  CONS[1] = 0;
                  BLDWRD[2] = COMCOUNT; 
                  OPC[3] = 30;
                  TABLE[3] = S"USEORG$";
                  INDEX[3] = COMLIST; 
                  CONS[3] = 0;
                  BLDWRD[4] = 0;
                  INSTOUT(LOC(BLDINST),5);
                  USEORG[COMBLK] = 1; 
                  USEPOS[COMBLK] = WORDSIZE;
                  USEORG[COMLIST] = COMCOUNT; 
                  USEPOS[COMLIST] = WORDSIZE; 
                  END 
              ELSE
                  BEGIN 
                  OPC[0] = S"VFD$"; 
                  COUNT[0] = 2; 
                  TABLE[1] = S"NULL"; 
                  CONS[1] = 0;
                  BLDWRD[2] = 0;
                  INSTOUT(LOC(BLDINST),3);
                  END 
              END 
          INSTOUT(LOC(ENDINST),1);
 #   ALLOCATE USE BLOCKS                                               #
          LOCN = 0; 
          FOR  J = 1 STEP 1 UNTIL BLOCKCNT DO 
              BEGIN 
              IF  USEPOS[J] NQ WORDSIZE THEN  USEORG[J] = USEORG[J] + 1;
              USELENGTH[J] = USEORG[J]; 
              IF  GLOBAL[J] 
              THEN
                  USESTART[J] = 0;
              ELSE
                  BEGIN 
                  USESTART[J] = LOCN; 
                  LOCN = USELENGTH[J] + LOCN; 
                  END 
              END 
          FLUSHWS;
          CLOSINS;
          SEGMENT = TRUE; 
          END 
          CONTROL  EJECT; 
          PROC  ASMFIN; 
          ITEM  I;
          BEGIN 
          FOR  I = 1 STEP 1 UNTIL BLOCKCNT DO 
              IF  USEPOOL[I]  THEN CMI$FRV(LOC(USEPOOLADR[I])); 
          IF NOT (CCTMEMORYMAP OR CCTTDF) 
          THEN
              CMM$FGR(USEID);   #IF NO MAP, FREE USE TABLE# 
          CLOBIN;            #CLOSE BINARY FILE                        #
          RTNINST;
          END 
          CONTROL  EJECT; 
          PROC  ASMINIT;
          ITEM  I;
          BEGIN 
          ATEMPCNT = 0; 
          ENDP = FALSE; 
          ENDSEQ = 1; 
          NATEMPS = 0;
          NEXTUP = S"UPYES";
          ORG = 0;
          POS = WORDSIZE; 
          INITRD; 
          OPENINS;
          FOR I = 1 STEP 1 UNTIL BLOCKCNT DO
              BEGIN 
              USEPOS[I] = WORDSIZE; 
              IF  NOT GLOBAL[I] 
              THEN
                  BEGIN 
                  USEORG[I] = 0;
                  END 
              USEPOOLSIZ[I] = 0;
              USEPOOLPTR[I] = 0;
              IF  USENAME[I] EQ "CODE   "  THEN  BLOCK = I; 
              IF  USENAME[I] EQ "PILST  "  THEN  ADSUBBLK = I;
              END 
          CODEBLOCK = BLOCK;
          END 
          CONTROL  EJECT;                                                COBASM 
          PROC  ASMSTART; 
          ITEM  I;                                                       COBASM 
          ITEM J;                                                        COBASM 
          ITEM  POOLSIZE; 
          XREF ITEM  NRESREG;                                            COBASM 
                                                                         COBASM 
          BEGIN                                                          COBASM 
 #   ALLOCATE STORAGE                                                  #
          SEQSIZE = 200;
          IF GROUP1FLAG EQ 0
          THEN
              GROUP1FLAG = CMM$AGR (1);  #ASGN ID FOR GROUP 1 BLOCKS# 
          J = CMM$ALV(SEQSIZE, 1, 3, GROUP1FLAG,P<SEQUENCE>, 0);
          LOCKLIM = 100;
          J = CMM$ALV(LOCKLIM+1, 1 ,3 ,GROUP1FLAG, P<LOCKLIST>, 0); 
          POOLSIZE = 100; 
          FOR  J = 1 STEP 1 UNTIL BLOCKCNT DO 
              BEGIN 
              IF  USEPOOL[J]
              THEN
                  BEGIN 
                  USEPOOLSIZ[J] = 0;
                  USEPOOLLIM[J] = POOLSIZE; 
                  I = LOC(USETAB);
                  I = CMM$ALV(POOLSIZE, 3, 3, GROUP1FLAG, P<USETAB>,
                              LOC(USEPOOLADR[J]) - B<42,18>I);
                  END 
              END 
          LINE = 0; 
          INITIN; 
          INITOUT;
          OPNBIN(CCTOBJFILE); 
          LOCKLINK[0] = 0;
          LOCKINST[0] = O"377777";
          SEGMENT = FALSE;
          END                                                            COBASM 
          CONTROL  EJECT; 
          BEGIN 
          ASMSTART; 
          DOWHILE  NOT INSTEOF  DO
              BEGIN 
              ASMINIT;
              IF  NOT INSTEOF 
              THEN
                  BEGIN 
                  DOWHILE  NOT ENDP  DO 
                      BEGIN 
                      RA$SUBPHASE = 1;
                      GETSEQ; 
                      RA$SUBPHASE = 2;
                      INSTGEN;
                      END 
                  ASMEND; 
                  RA$SUBPHASE = 3;
                  ASM2; 
                  END 
              END 
          ASMFIN; 
          RETURN; 
          END 
          TERM                                                           COBASM 
