*DECK             EDITSB
USETEXT   TSOURCE 
PROC EDITSB (ALN,POS,INT,ACHR,NCHR);
BEGIN#EDIT SUBROUTINES# 
#*******************************************************************# 
#*******************************************************************# 
     DEF  NWDLN 
               #12#;     #6600     WORDS/LINE                         6#
     DEF  BYTWD 
               #10#;     #6600     BYTES/WORD                         6#
     DEF  BITWD 
               #60#;     #6600     BITS/WORD                          6#
     DEF  BYTE
               #6#;     #1107,6600 BITS/BYTE                         76#
     DEF LBYTP
               #54#;     #6600     LAST BYTE POSITION                 6#
     DEF  HZERO 
               #O"33"#;       #6600     "0"                           6#
         DEF   HMINUS #O"46"#;  # MINUS # 
     DEF  HFILL 
                                    #O"55"#;   # 6600 BLANK # 
#*******************************************************************# 
          ITEM I,J,N,Q; #LOCAL TEMPS# 
          ITEM   SW,SB,KW,KB;      #LOCAL VARIABLES#
#*******************************************************************# 
  
         ARRAY ALN [NWDLN] S(1); ITEM LN C(0,0,BYTWD);
         ITEM POS,INT,NCHR; 
         ARRAY ACHR[NWDLN] S(1); ITEM CHR C(0,0,BYTWD); 
  
#*******************************************************************# 
ENTRY PROC BINOCT(ALN,POS,INT,NCHR);    #BIN TO OCT#
               KW = POS/BYTWD;     #LINE WORD#
               KB = (POS-KW*BYTWD)*BYTE;     #BYTE POSITION#
           FOR SB = BITWD-NCHR*3 STEP 3 UNTIL BITWD-3 DO
           BEGIN#SB#
               B<KB,BYTE>LN[KW] = B<SB,3>INT+HZERO; #OCT TO HOL#
               IF KB EQ LBYTP THEN
               BEGIN#E-O-WORD#
                    KB = 0;   #INIT BYTE INDEX# 
                    KW = KW+1; #INCR LINE INDEX#
               END  #E-O-WORD#
               ELSE KB = KB+BYTE;  #SAME WORD#
           END  #SB#
RETURN; 
#*******************************************************************# 
#*******************************************************************# 
ENTRY PROC BINDEC(ALN,POS,INT,NCHR);    #BIN TO DEC#
               ITEM DIV;  DIV=10; 
          KB = POS+NCHR-1;
          KW = KB/BYTWD;                #LINE WORD# 
          KB = (KB-KW*BYTWD)*BYTE;      #BYTE POSITION# 
                   GOTO PCVTD4; 
PCVTD0: 
                    B<KB,BYTE>LN[KW] = HFILL;     #FILL#
PCVTD2: 
                    IF I EQ 1 THEN RETURN;   #FILL COMPLETE#
                    #ELSE CONTINUE# 
                         I = I-1; 
                         IF KB EQ 0 THEN
                         BEGIN #E-O-WORD# 
                              KB = LBYTP;    #INIT BIT INDEX# 
                              KW = KW-1;     #DECR WRD INDEX# 
                         END   #E-O-WORD# 
                         ELSE KB = KB-BYTE;  #DECR BIT INDEX# 
                         GOTO PCVTD0; 
                    #END  CONTINUE# 
               #END   FILL# 
          #END   ZERO#
          #BEGIN - NON-ZERO#
PCVTD4: 
               N = INT; 
                        ITEM MINUS B; MINUS=TRUE; 
                    IF N LS 0 THEN BEGIN N=-N; MINUS=FALSE; END 
               FOR I = NCHR STEP -1 UNTIL 1 DO
               BEGIN#I# 
                              Q=N/DIV;
                              B<KB,BYTE>LN[KW]=(N-Q*DIV)+HZERO; 
                         IF Q EQ 0 THEN BEGIN    # COMPLETE # 
                                          IF MINUS THEN GOTO PCVTD2;
                                          Q=HMINUS-HZERO; DIV=1000; 
                                          MINUS=TRUE; 
                                        END 
                    #ELSE NOT COMPLETE# 
                         N = Q; 
                         IF KB EQ 0 THEN
                         BEGIN #E-O-WORD# 
                              KB = LBYTP;    #INIT BIT INDEX# 
                              KW = KW-1;     #DECR WRD INDEX# 
                         END   #E-O-WORD# 
                         ELSE KB = KB-BYTE;  #DECR BIT INDEX# 
                    #END  NOT COMPLETE# 
               END  #I# 
          #END   - NON-ZERO#
RETURN; 
#*******************************************************************# 
#*******************************************************************# 
$BEGIN
ENTRY PROC CHRCHR(ALN,POS,ACHR,NCHR);   #CHAR TO CHAR#
          SW = 0;   #SOURCE WORD INDEX# 
          KW = POS/BYTWD;          #WORD INDEX# 
          KB = (POS-KW*BYTWD)*BYTE;    #BYTE INDEX# 
          IF KB NQ 0 THEN GOTO CHRCH4;   #NOT WORD ALIGNED# 
          #ELSE WORD ALIGNED# 
               FOR I = NCHR STEP -BYTWD UNTIL 1        DO 
               BEGIN#I# 
                    IF I LS BYTWD THEN GOTO CHRCH2; 
                    #ELSE FULL WORD#
                         LN[KW] = CHR[SW];   #MOVE WORD#
                         KW = KW+1; 
                         SW = SW+1; 
                    #END  FULL WORD#
               END  #I# 
               RETURN;
                    #BEGIN LAST CHAR# 
CHRCH2: 
                         C<0,I>LN[KW] = C<0,I>CHR[SW];  #LAST CHAR# 
                         RETURN;
                    #END   LAST CHAR# 
          #END  WORD ALIGNED# 
          #BEGIN NOT WORD ALIGNED # 
CHRCH4: 
               FOR I = NCHR STEP -BYTWD UNTIL 1        DO 
               BEGIN#I# 
                    IF I LS BYTWD THEN GOTO CHRCH6; 
                    #ELSE FULL WORD#
                         FOR SB = 0 STEP BYTE UNTIL LBYTP DO
                         BEGIN#J# 
                              B<KB,BYTE>LN[KW] = B<SB,BYTE>CHR[SW]; 
                              IF KB GQ LBYTP THEN 
                              BEGIN#E-O-WORD# 
                                   KB = 0;
                                   KW = KW+1; 
                              END  #E-O-WORD# 
                              ELSE KB = KB+BYTE;
                         END  #J# 
                         SW = SW+1; 
                    #END  FULL WORD#
               END  #I# 
               RETURN;
                    #BEGIN PARTIAL WORD#
CHRCH6: 
                         FOR SB = 0 STEP BYTE WHILE I GR 0 DO 
                         BEGIN#J# 
                              B<KB,BYTE>LN[KW] = B<SB,BYTE>CHR[SW]; 
                              IF KB GQ LBYTP THEN 
                              BEGIN#E-O-WORD# 
                                   KB = 0;
                                   KW = KW+1; 
                              END  #E-O-WORD# 
                              ELSE KB = KB+BYTE;
                              I = I-1;
                         END  #J# 
                    #END   PARTIAL WORD#
          #END   NOT WORD ALIGNED # 
RETURN; 
$END
#*******************************************************************# 
#*******************************************************************# 
END  #EDIT SUBROUTINES# 
      TERM
