*DECK C$INSPF 
          IDENT  C$INSPF
          TITLE  CBINSPF - PROCESS INSPECT STATEMENT
  
          MACHINE  ANY,I
          COMMENT  PROCESS INSPECT STATEMENT
          SST 
          B1=1
 C.INSPT  SPACE  4
* 
*         C.INSPF - FAST INSPECT
* 
*         CALLING SEQUENCE
*         RJ     C.INSPF OR C.INSRF 
* 
*         INPUT 
*                B3 = RESULT ADDRESS
*                B4 = RESULT BCP (+ SUBSC CHAR OFFSET IF SUBSCRIPTED) 
*                B5 = PARAMETER LIST ADDRESS
*                B6 = LAST PARAMETER ADDRESS
*                B7 = RESULT LENGTH 
* 
*         PARAMETER LIST
* 
*         VFD    6/TYPE,18/LENGTH,18/OFFSET,18/ADDRESS
* 
*      TYPE HAS THE FOLLOWING VALUES
*      NOTE THAT 60B IS ALSO THE STRING/UNSTRING IDENTIFIER DELIM PARAM 
*         00B = CHARS SEARCH SPECIFICATION (+ ITEM TO REPACE BY)
*         01B =     CHARS SEARCH SPEC (+ SIGNED LEFT NUMERIC REPL. ITEM)
*         02B =     CHARS SEARCH SPEC (+ SIGNED RIGHT NUMERIC REPL ITEM)
*         10B = ALL SEARCH SPECIFICATION (+ ITEM TO SEARCH FOR) 
*         11B =     ALL SEARCH SPEC (+ SIGNED LEFT NUMERIC SEARCH ITEM) 
*         12B =     ALL SEARCH SPEC (+ SIGNED RIGHT NUMERIC SEARCH ITEM)
*         20B = LEADING SEARCH SPECIFICATION (+ ITEM TO SEARCH FOR) 
*         21B =     LEADING SEARCH SPEC (+ SIGNED LEFT NUMERIC ITEM)
*         22B =     LEADING SEARCH SPEC (+ SIGNED RIGHT NUMERIC ITEM) 
*         30B = FIRST SEARCH SPECIFICATION (+ ITEM TO SEARCH FOR) 
*         31B =     FIRST SEARCH SPEC (+ SIGNED LEFT NUMERIC SEARCH ITM)
*         32B =     FIRST SEARCH SPEC (+ SIGNED RIGHT NUMERIC SRCH ITEM)
*         40B = ITEM TO REPLACE BY (+ OPERAND TO REPLACE BY)
*         41B =     ITEM TO REPLACE BY (+ SIGNED LEFT NUMERIC REPL ITEM)
*         42B =     ITEM TO REPLACE BY (+ SIGNED RIGHT NUMERIC REPL ITM)
*         60B = BEFORE SEARCH BOUNDARY (+ BOUNDARY ITEM)
*         61B =     BEFORE SEARCH BOUNDARY (+ SIGNED LEFT NUMERIC BOUND)
*         62B =     BEFORE SEARCH BOUNDARY (+ SIGNED LEFT NUMERIC BND)
*         70B = AFTER SEARCH BOUNDARY (+ BOUNDARY ITEM) 
*         71B =     AFTER SEARCH BOUNDARY (+ SIGNED LEFT NUMERIC BOUND) 
*         72B =     AFTER SEARCH BOUNDARY (+ SIGNED RIGHT NUMERIC BOUND)
* 
*      TALLY PARAMETER GROUP IS CONSTRUCTED AS FOLLOWS
* 
*         SEARCH SPECIFICATION
*        [BOUNDARY     ]               * IF BEFORE/AFTER
* 
*      REPLACE PARAMETER GROUP IS CONSTRUCTED AS FOLLOWS
* 
*         SEARCH SPECIFICATION
*        [BOUNDARY     ]               * IF BEFORE/AFTER
*        [REPLACE ITEM ]               * IF NOT CHAR SPECIFICATION
* 
*         OUTPUT
*                X2 = TALLY VALUE TO ADD TO TALLY ITEM
* 
*         USES -
*                ASSUMES B1=1 
*                ALL REGISTERS EXCEPT A0, X1
* 
*         PHILOSOPHY OF DESIGN
*         THE C.INSPT ROUTINE SHOULD DO AS MUCH OF THE INSPECT VERB 
*         OPERATION AS POSSIBLE. IT SHOULD BE FAST AND AS SMALL AS
*         POSSIBLE. NUMERIC OPERANDS ARE THE BANE OF THIS OPERATION,
*         DUE TO THEIR VARIED CHARACTERISTICS. FORTUNATELY DECIMAL
*         POINT PLACEMENT IS NOT A WORRY. THREE KINDS OF SIGNS ARE
*         TAKEN CARE OF IN THE GENERATION BY GSTRING, LEAVING ONLY
*         OVERPUNCHED SIGNS TO BE HANDLED AT OBJECT TIME. 
* 
** CONDITIONS OF USE -
*         ONLY ONE SCAN ITEM
*         SCAN ITEM (INCLUDING BEFORE/AFTER ITEM) 10 CHARACTERS OR LESS 
*         IN LENGTH.
  
          EJECT 
*      INSPECT REPLACING ENTRY POINT
  
          ENTRY  C.INSRF
 C.INSRF  DATA   0
  
          SX7    B1 
          SA7    REPLACE           * SET REPLACE FLAG TO TRUE 
          EQ     C.INSP            * USE COMMON CODE WITH TALLYING
  
*      INSPECT TALLYING ENTRY POINT 
  
          ENTRY  C.INSPF
 C.INSPF  DATA   0
  
          MX7    0
          SA7    REPLACE           * SET REPLACE FLAG TO FALSE
  
*      FINISH INSPECT FIELD SUBSCRIPT CALCULATIONS
  
 C.INSP   BSS    0                 * ENTRY FROM INSPECT REPLACING 
  
          RJ     STRSUBS           * STRSUBS INPUT: B3 = ADDR, B4 = OFFS
                                   *    OUTPUT: B3 = NEW ADDR, B4 = BCP 
                                   *          USES: X2, X4, X5
  
*      SAVE REGISTER PARAMETERS 
  
          SX7    B3 
          SA7    INSPADDR          * B3 = INSPECT FIELD ADDR (MODIFIED) 
          SX7    B4 
          SA7    INSPBCP           * B4 = INSPECT FIELD BCP (MODIFIED)
          SX7    B5 
          SA7    PARMAD            * B5 = PARAMETER ADDRESS 
          SX7    B6 
          SA7    PARMEND           * B6 = LAST PARAMETER ADDRESS
          SX7    B7 
          SA7    INSPLEN           * B7 = INSPECT FIELD LENGTH
          SX7    X1 
          SA7    X1SAVE            * SAVED REGISTER 
  
*      INITIALIZE TALLY COUNT 
  
          MX7    0
          SA7    TALLYCNT          * TALLY INITIALIZED TO 0 
  
          SPACE  4
  
*      CHECK IF THERE IS A BEFORE/AFTER OPERAND FOR THIS COMPARE OPERAND
          MX7    0                 * SET BEFORE/AFTER TYPE TO 
          SA7    BEFORTYP          * NO BEFORE/AFTER
  
          EQ     B5,B6,NOBEFORE    * BRANCH IF ONLY ONE OPERAND 
                                   * THEREFORE NO BEFORE/AFTER. 
                                   * USE UNMODIFIED INSPECT ITEM DESC.
  
          SA2    B5+B1             * GET OPERAND AFTER FIRST ONE
          MX3    3
          BX3    X3*X2
          LX3    3
          SB5    X3                * B5 = PARAMETER TYPE CODE 
          SB6    6B                * B6 = 60B  BEFORE/AFTER TYPE BOUND
          LT     B5,B6,NOBEFORE    * BRANCH IF NO BEFORE/AFTER
                                   * USE ORIGINAL INSPECT ITEM DESCR. 
  
*      THERE IS A BEFORE/AFTER ITEM. SCAN FOR IT. 
*      SET UP PARAMETERS FOR SCAN ROUTINE.
  
          SX7    X3 
          SA7    BEFORTYP          * SAVE BEFORE/AFTER TYPE CODE
          MX3    3
          LX3    57 
          BX3    X3*X2
          AX3    54 
          SB2    X3                * TYPE 
  
          SB5    X2                * B5 = BEFORE/AFTER ITEM ADDRESS 
          LX2    24 
          SX3    X2                * X3 = BEFORE/AFTER ITEM LENGTH
          LX2    18 
          SX2    X2                * X2 = BEFORE/AFTER ITEM OFFSET
  
*      FINISH BEFORE/AFTER ITEM SUBSCRIPTING
  
          RJ     SRCSUBS           * SRCSUBS INPUT: B5 = ADDR, X2 = OFFS
                                   *    OUTPUT: B5 = NEW ADDR, B6 = BCP 
                                   *          USES: X2, X4, X5
  
*      GET SCAN ITEM, PUT IN X7 
  
          RJ     LOADSCAN          * INPUT: B5 = SCAN ADDR, B6 = SCAN BC
                                   *        X3 = SCAN LENGTH
                                   *       B2 = TYPE
                                   * OUTPUT: X7 = SCAN ITEM 
                                   * USES: C.MASK 
                                   *       A2,A4,A5, B5-6, X0,X2,X4,X5
                                   * SAVES: B3, B4, B7, X3
  
          SPACE  4
*      AT THIS POINT, THE SCAN ITEM IS IN X7, LEFT JUSTIFIED, 
*      AND ZERO FILLED. 
*      NOW GET THE INSPECT FIELD, AND PUT IT IN X6. 
  
          RJ     LOADINSP          * INPUT: B3 = INSP ADDR, B4 = INSP BC
                                   *        B7 = INSP LENGTH
                                   *        X3 = SCAN LENGTH
                                   * OUTPUT: X0 = CHAR COUNT BEFORE LOAD
                                   *         X2 = RESERVE WORD OF INSP
                                   *         X6 = INSP ITEM 
                                   * USES: C.MASK 
                                   *       A2,A5, B5, X0,X2,X4-6
                                   * SAVES: B3, B4, B7, X3, X7
  
*      CALL SCAN ROUTINE TO FIND BEFORE/AFTER BOUNDARY
  
          RJ     SCANFOR           * INPUT: B3 = INSPECT ITEM ADDRESS 
                                   *        B4 = INSPECT ITEM BCP 
                                   *        B5 = BEFORE/AFTER ADDRESS 
                                   *        B6 = BEFORE/AFTER BCP 
                                   *        B7 = INSPECT ITEM LENGTH
                                   *        X3 = BEFORE/AFTER LENGTH
                                   * OUTPUT: X4 = SCAN LENGTH 
                                   * SAVES: B3, B4, B7
  
*      THE BEFORE/AFTER SCAN LENGTH IS NOW KNOWN
*      CHANGE THE INSPECT ITEM DESCRIPTION TO CORRESPOND
  
          SA5    BEFORTYP 
          SX5    X5-6        BEFORE 
          NZ     X5,AFTERBND       * PROCESS AFTER TYPE IF NONZERO
  
*      BEFORE BOUNDARY--ONLY THE LENGTH NEED BE CHANGED 
  
          SB7    X4                * B7 = LENGTH BEFORE SCAN ITEM 
          EQ     NOBEFORE          * SKIP TO MAIN INSPECT PROCESSING
  
 AFTERBND BSS    0
  
*      AFTER BOUNDARY--CHANGE LENGTH TO 
*         LENGTH - (SCAN LENGTH + SCAN ITEM LENGTH) 
  
          SB6    X4                * B6 = SCAN LENGTH 
  
*      DONT SUBTRACT SCAN ITEM LENGTH IF SCAN WAS TO END OF INSPECT ITEM
  
          EQ     B7,B6,SKIPCALC 
  
*      GET SCAN ITEM LENGTH AND SUBTRACT IT OFF TOO 
  
          SA5    PARMAD 
          SA5    X5+B1             * X5 = AFTER PARAMETER 
          LX5    24 
          SB5    X5                * B5 = SCAN ITEM LENGTTH 
          SB6    B5+B6             * B6 = SCAN LENGTH + SCAN ITEM LENGTH
  
*      NOW THE LENGTH TO MODIFY THE INSPECT ITEM IS KNOWN.
*      CHANGE ADDRESS AND LENGTH CORRESPONDINGLY. 
  
 SKIPCALC BSS    0
  
          SB7    B7-B6             * B7 = LEN - (SCAN-L + SCAN-ITEM-L)
          SB4    B4+B6             * B4 = BCP + SCAN-L + SCAN-ITEM-L
  
*      RECOMPUTE ADDRESS AND BCP OF INSPECT ITEM
  
          RJ     STRSUBS           * STRSUBS INPUT: B3 = ADDR, B4 = OFFS
                                   *    OUTPUT: B3 = NEW ADDR, B4 = BCP 
                                   *         USES: X2, X4, X5 
  
*      NOW THE BOUNDARIES FOR THE INSPECT ITEM HAVE BEEN ESTABLISHED. 
*      DO THE MAIN INSPECT OPERATION. 
  
 NOBEFORE BSS    0
  
*      FIND THE KIND OF INSPECT THIS IS--CHARACTERS, ALL, LEADING, FIRST
  
          SA5    PARMAD 
          SA5    X5                * GET SPECIFICATION PARAMETER
          MX2    3
          BX2    X2*X5
          LX2    3                 * X2 = FIRST SPECIFICATION TYPE DIGIT
          SB5    X2 
          NZ     B7,TYPEBR
          SA5    REPLACE     AFTER NOT FOUND, EXIT
          NZ     X5,C.INSPRX
          MX2    0           TALLY = 0
          EQ     C.INSPTX 
TYPEBR    BSS    0
  
          EQ     B5,B0,CHARINSP    * TYPE 0X = CHARACTERS SPECIFICATION 
          EQ     B5,B1,ALLINSP     * TYPE 1X = ALL SPECIFICATION
          SB6    B1+B1
          EQ     B5,B6,LEADINSP    * TYPE 2X = LEADING SPECIFICATION
          EQ     FRSTINSP          * TYPE 5X = FIRST SPECIFICATION
  
          SPACE  4
*      THIS IS INSPECT FOR CHARACTERS.
*      FIND IF IT IS TALLYING OR REPLACING
  
 CHARINSP BSS    0
          SA5    REPLACE           * GET INSPECT REPLACING FLAG 
          NZ     X5,CHARREPL       * IF NONZERO, THIS IS CHAR REPLACING 
  
          SPACE  4
*      THIS IS: 
*         INSPECT A TALLYING T FOR CHARACTERS (BEFORE/AFTER B)
*      THE TALLY TO BE RETURNED IS THE (MODIFIED) INSPECT ITEM LENGTH 
  
          SX2    B7 
          EQ     C.INSPTX          * RETURN TO CALLER 
  
          SPACE  4
*      THIS IS: 
*         INSPECT A REPLACING CHARACTERS BY R (BEFORE/AFTER B)
  
 CHARREPL BSS    0
  
*      LOAD REPLACE CHARACTER LEFT ALIGNED. 
*      IT IS THE LAST ITEM IN THE PARAMETER GROUP.
  
          SA5    PARMAD 
          SA5    X5                * GET LAST PARAMETER 
          SB5    X5                * B5 = ADDR REPLACE CHAR 
          LX5    42 
          SX2    X5                * X2 = OFFSET REPLACE CHAR 
  
*      FINISH REPLACE CHAR ITEM SUBSCRIPTING
  
          RJ     SRCSUBS           * SRCSUBS INPUT: B5 = ADDR, X2 = OFFS
                                   *    OUTPUT: B5 = WORD CNT, B6 = PTR 
                                   *          USES: X2,X4,X5
  
          SA5    B5                * GET REPLACE CHARACTER WORD 
  
          SB5    B6+B6
          SB6    B5+B5
          SB6    B5+B6             * B5 = BCP * 6 
  
          LX5    B6,X5             * SHIFT REPLACE CHAR TO LEFT BOUNDARY
          MX4    6
          BX5    X4*X5             * ISOLATE REPLACE CHARACTER
  
*      PROPAGATE REPLACE CHARACTER THROUGH A FULL WORD. 
*      THIS CODE COULD BE DELETED IF LPOOLER DID THIS WORK. 
  
          BX4    X5 
          LX4    54 
          BX5    X5+X4             * TWO CHARS LEFT ALIGNED 
          BX4    X5 
          LX4    48 
          BX3    X5+X4             * FOUR CHARS LEFT ALIGNED
          BX4    X3 
          LX4    36 
          BX4    X3+X4             * EIGHT CHARS LEFT ALIGNED 
          LX5    12 
          BX6    X5+X4             * TEN CHARS LEFT ALIGNED 
  
*      STORE REPLACE CHARACTERS IN INSPECT ITEM 
  
          SB5    B0 
          SX2    B4+B7
          SB5    10 
          SB2    B5-B4       10 - OFFSET
          SX3    X2-10
          PL     X3,CHARPL1 
          SB2    B7          CHARACTERS IN FIRST WORD 
 CHARPL1  SA3    B2+=XC.MASK
          SB6    B4+B4
          SB6    B6+B4
          SB6    B6+B6       6*OFFSET 
          SB4    60 
          SB6    B4-B6
          LX4    B6,X3       POSITION MASK
          SA5    B3          FIRST WORD INSPEC ITEM 
          BX7    -X4*X5 
          BX5    X4*X6
          BX7    X5+X7
          SA7    B3 
          SB7    B7-B2       DECREMENT INSPECT LENGTH 
          ZR     B7,C.INSPRX
          BX7    X6 
 CHARPL2  SB7    B7-B5       LENGTH - 10
          LT     B7,B0,CHARPL3         LESS THAN ONE WORD LEFT
          SA7    A7+B1
          EQ     CHARPL2
          SPACE  3
 CHARPL3  SB7    B7+10       REMAINING CHARACTERS 
          SA5    B7+=XC.MASK
          SA3    A7+B1
          BX7    X5*X6
          BX5    -X5*X3 
          BX7    X7+X5
          SA7    A3 
          EQ     C.INSPRX 
  
          SPACE  4
*      THIS IS INSPECT FOR ALL
*      FIND IF IT IS TALLYING OR REPLACING
  
 ALLINSP  BSS    0
          SA5    REPLACE           * GET INSPECT REPLACING FLAG 
          NZ     X5,ALLREPL        * IF NONZERO, THIS IS REPLACING ALL
  
          SPACE  4
*      THIS IS: 
*         INSPECT A TALLYING T FOR ALL I (BEFORE/AFTER B) 
  
*      INITIALIZE TALLY COUNT 
          MX7    0
          SA7    TALLYCNT 
  
*      SET UP THE SCAN ITEM TO SCAN FOR.
*      LOAD THE SCAN ITEM AND FIRST SECTION OF THE INSPECT ITEM.
  
          RJ     SCANSET
  
  
*      CALL SCAN ROUTINE TO FIND FIRST OCCURRENCE OF SCAN ITEM. 
*      ***WARNING***--THE REGISTERS USED BY SCANFOR MUST BE SAVED 
*      IN THE FOLLOWING LOOP CODE.
  
          RJ     SCANFOR           * INPUT: B3 = INSPECT ITEM ADDRESS 
                                   *        B4 = INSPECT ITEM BCP 
                                   *        B5 = BEFORE/AFTER ADDRESS 
                                   *        B6 = BEFORE/AFTER BCP 
                                   *        B7 = INSPECT ITEM LENGTH
                                   *        X3 = BEFORE/AFTER LENGTH
                                   * OUTPUT: X4 = SCAN LENGTH 
                                   * SAVES: B3, B4, B7
  
 TALLYLP  BSS    0
  
*      IF END OF INSPECT ITEM, LOAD TALLY COUNT AND EXIT. 
  
          NE     B5,B0,TALLYLP1    * BRANCH IF NOT END OF ITEM
  
          SA2    TALLYCNT          * END OF ITEM, LOAD TALLY COUNT
          EQ     C.INSPTX          * RETURN TO CALLER 
  
*      NOT END OF INSPECT ITEM. 
*      INCREMENT TALLY COUNT AND RETURN FOR MORE SCANNING.
  
 TALLYLP1 BSS    0
  
*      RETURN FOR MORE SCANNING.
*      NOTE--ADVANTAGE IS TAKEN OF THE FACT THAT THE RETURN ADDRESS 
*      IN ROUTINE SCANFOR IS STILL AVAILABLE FROM THE  RJ SCANFOR 
*      JUST BEFORE TALLYLP. THUS, ALTHOUGH SCANFOR IS REENTERED FROM
*      HERE, THE RETURN FROM SCANFOR IS TO TALLYLP. 
  
          EQ     TALLRETN          * RETURN TO SCANFOR TO CONTINUE SCAN 
  
          SPACE  4
*      THIS IS: 
*         INSPECT A REPLACING ALL I BY R (BEFORE/AFTER B) 
  
 ALLREPL  BSS    0
          SA5    PARMAD 
          SA5    X5          SCAN PARAMETER DESCRIPTOR
          MX3    3
          LX3    57 
          BX7    X3*X5       TYPE 
          NZ     X7,ALLREPL1 SIGNED NUMERIC 
          LX5    24 
          SX3    X5-1 
          NZ     X3,ALLREPL1 NOT LENGTH ONE 
          SA5    PARMEND
          SA5    X5          REPLACE ITEM DESCRIPTOR
          LX5    3
          MX3    3
          BX7    X3*X5
          ZR     X7,ALLREPL2 NOT SIGNED NUMERIC 
 ALLREPL1 BSS    0
*      SET UP THE SCAN ITEM TO SCAN FOR.
*      LOAD THE SCAN ITEM AND FIRST SECTION OF THE INSPECT ITEM.
  
          RJ     SCANSET
  
*      CALL SCAN ROUTINE TO FIND SCAN ITEM
  
          RJ     SCANFOR           * INPUT: B3 = INSPECT ITEM ADDRESS 
                                   *        B4 = INSPECT ITEM BCP 
                                   *        B5 = BEFORE/AFTER ADDRESS 
                                   *        B6 = BEFORE/AFTER BCP 
                                   *        B7 = INSPECT ITEM LENGTH
                                   *        X3 = BEFORE/AFTER LENGTH
                                   * OUTPUT: X4 = SCAN LENGTH 
                                   * SAVES: B3, B4, B7
  
*      IF END OF INSPECT ITEM,EXIT
  
          EQ     B5,B0,C.INSPRX    * SCAN ITEM NOT FOUND
  
*      NOT END OF INSPECT ITEM. 
*      DO REPLACEMENT AND RETURN FOR MORE SCANNING. 
  
          RJ     STORREPL          * DO REPLACEMENT 
          EQ     B7,B0,C.INSPRX    * END OF INSPECT ITEM
  
          EQ     ALLREPL           * LOOP FOR MORE SCANNING 
  
          SPACE  3
*      REPLACING ALL - LENGTH ONE 
 ALLREPL2 BSS    0
          SA5    PARMAD 
          SA5    X5 
          SB5    X5          BCP SCAN ITEM
          LX5    42 
          SX2    X5          ADDR SCAN ITEM 
          RJ     SRCSUBS     OUTPUT  B5-NEW ADDR, B6-BCP
          SA1    B5          LOAD ITEM
          SB5    B6+B6
          SB6    B5+B6
          SB5    B6+B6
          LX1    B5,X1       LEFT JUSTIFY ITEM
          MX0    6
          BX1    X0*X1       ZERO FILL ITEM 
          SA5    PARMEND
          SA5    X5 
          SB5    X5          BCP REPL ITEM
          LX5    42 
          SX2    X5          ADDR REPL ITEM 
          RJ     SRCSUBS     OUTPUT  B5 - NEW ADDR, B6 - BCP
          SA2    B5          LOAD REPL ITEM 
          SB5    B6+B6
          SB6    B6+B5
          SB5    B6+B6
          LX2    B5,X2       LEFT JUSTIFY 
          BX2    X0*X2       ZERO FILL
*      AT THIS POINT  B3 - INSPECT ITEM ADDR
*                     B4 - INSPECT ITEM BCP 
*                     B7 - INSPECT ITEM LENGTH
*                     X1 - SCAN ITEM
*                     X2 - REPLACE ITEM 
          SA3    B3          INSPECT ITEM 
          SB5    B4+B4
          SB6    B5+B4
          SB5    B6+B6
          LX3    B5,X3       LEFT JUSTIFY 
          SB2    10 
          SB4    B2-B4
 ALLR0    SB2    B0          REPLACE FLAG 
          SB5    B0          SHIFT COUNT FOR REPLACE
          LT     B4,B7,ALLR1
          SB5    B4-B7
          SB6    B5+B5
          SB5    B6+B5
          SB5    B5+B5
          SB4    B7          CHARS IN WORD
 ALLR1    BSS    0
          SB7    B7-B4       CHARS REMAINING
 ALLR2    BX7    X0*X3
          BX6    X7-X1
          NZ     X6,ALLR3    NO MATCH 
          SB2    B1          REPLACE DONE 
          BX7    -X0*X3 
          BX3    X7+X2
 ALLR3    SB4    B4-B1
          LX3    6
          NZ     B4,ALLR2    MORE CHARACTERS
          EQ     B2,B0,ALLR4 NO REPLACE DONE
          LX7    X3,B5
          SA7    A3          STORE MODIFIED WORD
 ALLR4    BSS    0
          EQ     B7,B0,C.INSPRX 
          SA3    A3+B1       NEXT WORD
          SB4    10          CHARS IN WORD
          EQ     ALLR0
          SPACE  4
*      THIS IS INSPECT FOR LEADING
*      FIND IF IT IS TALLYING OR REPLACING
  
 LEADINSP BSS    0
          SA5    REPLACE           * GET INSPECT REPLACING FLAG 
          NZ     X5,LEADREPL       * IF NONZERO, THIS IS REPLACING LEADI
  
          SPACE  4
*      THIS IS: 
*         INSPECT A TALLYING T FOR LEADING I (BEFORE/AFTER B) 
  
*      INITIALIZE TALLY COUNT 
          MX7    0
          SA7    TALLYCNT 
          SA7    SCANCNT
  
*      SET UP THE SCAN ITEM TO SCAN FOR.
*      LOAD THE SCAN ITEM AND FIRST SECTION OF THE INSPECT ITEM.
  
          RJ     SCANSET
  
  
  
*      CALL SCAN ROUTINE TO FIND FIRST OCCURRENCE OF SCAN ITEM. 
*      ***WARNING***--THE REGISTERS USED BY SCANFOR MUST BE SAVED 
*      IN THE FOLLOWING LOOP CODE.
  
          RJ     SCANFOR           * INPUT: B3 = INSPECT ITEM ADDRESS 
                                   *        B4 = INSPECT ITEM BCP 
                                   *        B5 = BEFORE/AFTER ADDRESS 
                                   *        B6 = BEFORE/AFTER BCP 
                                   *        B7 = INSPECT ITEM LENGTH
                                   *        X3 = BEFORE/AFTER LENGTH
                                   * OUTPUT: X4 = SCAN LENGTH 
                                   * SAVES: B3, B4, B7
  
 REPLLP   BSS    0
          EQ     B5,B0,REPLLP0    * END OF INSPECT ITEM 
  
*      IF SCANFOR SKIPPED ANY CHARACTERS, LOAD TALLY COUNT AND EXIT.
  
          SA5    SCANCNT
          IX5    X5-X4             * X5 = COMPARE SCAN - SCAN COUNT 
          ZR     X5,REPLLP1        * CONTINUE IF EQUAL
  
 REPLLP0  BSS    0
          SA2    TALLYCNT 
          EQ     C.INSPTX          * RETURN TO CALLER 
  
*      SCAN ITEM LEADS INSPECT ITEM.
*      INCREMENT COMPARISON SCAN COUNT AND TALLY COUNT, AND RETURN
*      FOR MORE SCANNING. 
  
 REPLLP1  BSS    0
          SA5    SCANCNT
          IX5    X5+X3             * INCREMENT SCAN COUNT AND SAVE
          SA0    X5 
          BX5    X7                * SAVE X7 ACROSS STORE 
          SX7    A0 
          SA7    SCANCNT           * STORE SCAN COUNT 
          BX7    X5                * RESTORE X7 
  
*      RETURN FOR MORE SCANNING.
*      NOTE--ADVANTAGE IS TAKEN OF THE FACT THAT THE RETURN ADDRESS IN
*      SCANFOR IS STILL AVAILABLE FROM THE  RJ SCANFOR  JUST BEFORE 
*      REPLLP. THUS, ALTHOUGH SCANFOR IS REENTERED FROM HERE, THE 
*      RETURN FROM SCANFOR IS TO REPLLP.
  
          EQ     TALLRETN          * RETURN TO SCANFOR TO CONTINUE SCAN 
  
          SPACE  4
*      THIS IS: 
*         INSPECT A REPLACING LEADING I BY R (BEFORE/AFTER B) 
  
 LEADREPL BSS    0
          SA5    PARMAD 
          SA5    X5          SCAN PARAMETER DESCRIPTOR
          MX3    3
          LX3    57 
          BX7    X3*X5       TYPE 
          NZ     X7,LEAD1    SIGNED NUMERIC 
          LX5    24 
          SX3    X5-1 
          NZ     X3,LEAD1    NOT LENGTH ONE 
          SA5    PARMEND
          SA5    X5          REPLACE ITEM DESCRIPTOR
          LX5    3
          MX3    3
          BX7    X3*X5
          ZR     X7,LEAD2    NOT SIGNED NUMERIC 
 LEAD1    BSS    0
*      SET UP THE SCAN ITEM TO SCAN FOR.
*      LOAD THE SCAN ITEM AND FIRST SECTION OF THE INSECT ITEM. 
  
          RJ     SCANSET
  
*      CALL SCAN ROUTINE TO FIND SCAN ITEM
  
          RJ     SCANFOR           * INPUT: B3 = INSPECT ITEM ADDRESS 
                                   *        B4 = INSPECT ITEM BCP 
                                   *        B5 = BEFORE/AFTER ADDRESS 
                                   *        B6 = BEFORE/AFTER BCP 
                                   *        B7 = INSPECT ITEM LENGTH
                                   *        X3 = BEFORE/AFTER LENGTH
                                   * OUTPUT: X4 = SCAN LENGTH 
                                   * SAVES: B3, B4, B7
  
*      IF SCANFOR SKIPPED ANY CHARACTERS, EXIT
  
          NZ     X4,C.INSPRX       * BRANCH IF CHARS WERE SKIPPED 
  
*      NOT END OF INSPECT ITEM. 
*      DO REPLACEMENT AND RETURN FOR MORE SCANNING. 
  
          RJ     STORREPL          * DO REPLACEMENT 
          EQ     B7,B0,C.INSPRX    * END OF INSPECT ITEM
  
          EQ     LEADREPL          * LOOP FOR MORE SCANNING 
          SPACE  3
*      REPLACING LEADING - LENGTH ONE 
 LEAD2    BSS    0
          SA5    PARMAD 
          SA5    X5 
          SB5    X5          BCP SCAN ITEM
          LX5    42 
          SX2    X5          ADDR SCAN ITEM 
          RJ     SRCSUBS     OUTPUT  B5-NEW ADDR, B6-BCP
          SA1    B5          LOAD ITEM
          SB5    B6+B6
          SB6    B5+B6
          SB5    B6+B6
          LX1    B5,X1       LEFT JUSTIFY SCAN ITEM 
          MX0    6
          BX1    X0*X1       ZERO FILL
          SA5    PARMEND
          SA5    X5          REPL ITEM DESCRIPTOR 
          SB5    X5          BCP REPL ITEM
          LX5    42 
          SX2    X5          ADDR REPL ITEM 
          RJ     SRCSUBS     OUTPUT  B5- NEW ADDR, B6-BCP 
          SA2    B5          LOAD REPL ITEM 
          SB5    B6+B6
          SB6    B6+B5
          SB5    B6+B6
          LX2    B5,X2       LEFT JUSTIFY 
          BX2    X0*X2       ZERO FILL
*      AT THIS POINT  B3 - INSPECT ITEM ADDR
*                     B4 - INSPECT ITEM BCP 
*                     B7 - INSPECT ITEM LENGTH
*                     X1 - SCAN ITEM
*                     X2 - REPLACE ITEM 
          SA3    B3          INSPECT ITEM 
          SB5    B4+B4
          SB6    B5+B4
          SB5    B6+B6
          LX3    B5,X3       LEFT JUSTIFY 
          SB2    10 
          SB4    B2-B4
 LEAD3    BSS    0
          SB5    B0          SHIFT COUNT FOR STORE
          LT     B4,B7,LEAD4 FULL WORD
          SB5    B4-B7
          SB4    B7 
 LEAD4    BSS    0
          SB7    B7-B4       CHARS REMAINING
 LEAD5    BSS    0
          BX7    X0*X3
          BX6    X7-X1
          NZ     X6,LEAD6    NO MATCH 
          SB2    B1 
          BX7    -X0*X3 
          BX3    X7+X2
          SB4    B4-B1
          LX3    6
          NZ     B4,LEAD5    MORE CHARACTERS
          SB6    B5+B5
          SB5    B6+B5
          SB5    B5+B5
          LX7    B5,X3
          SA7    A3          REPLACE WORD 
          EQ     B7,B0,C.INSPRX 
          SA3    A3+B1
          SB4    10 
          EQ     LEAD3
          SPACE  3
 LEAD6    BSS    0
          SB5    B5+B4       ADJUST SHIFT COUNT 
          SB6    B5+B5
          SB5    B5+B6
          SB6    B5+B5
          LX7    X3,B6
          SA7    A3          STORE POSSIBLY MODIFIED WORD 
          EQ     C.INSPRX 
  
          SPACE  4
*      THIS IS INSPECT FOR REPLACING FIRST: 
*         INSPECT A REPLACING FIRST I BY R (BEFORE/AFTER B) 
  
 FRSTINSP BSS    0
  
*      SET UP THE SCAN ITEM TO SCAN FOR.
*      LOAD THE SCAN ITEM AND FIRST SECTION OF THE INSPECT ITEM.
  
          RJ     SCANSET
  
*      CALL SCAN ROUTINE TO FIND FIRST OCCURRENCE OF SCAN ITEM. 
  
          RJ     SCANFOR           * INPUT: B3 = INSPECT ITEM ADDRESS 
                                   *        B4 = INSPECT ITEM BCP 
                                   *        B5 = BEFORE/AFTER ADDRESS 
                                   *        B6 = BEFORE/AFTER BCP 
                                   *        B7 = INSPECT ITEM LENGTH
                                   *        X3 = BEFORE/AFTER LENGTH
                                   * OUTPUT: X4 = SCAN LENGTH 
                                   * SAVES: B3, B4, B7
  
*      CHECK IF SCAN ITEM WAS NOT FOUND, AND EXIT IF SO.
*      B7 = SAVED INSPECT ITEM LENGTH 
  
          SB5    X4                * B5 = SCAN LENGTH 
          EQ     B5,B7,C.INSPRX    * EXIT IF SCAN LENGTH = INSPECT LENGT
  
*      DO THE REPLACEMENT.
  
          RJ     STORREPL          * DO REPLACEMENT 
          EQ     C.INSPRX          * RETURN TO CALLER 
  
          SPACE  4
*      RETURN CODE FOR RETURN TO CALLER 
  
 C.INSPTX BSS    0
          SA1    X1SAVE            * RESTORE X1 
          EQ     C.INSPF
  
          SPACE  4
 C.INSPRX BSS    0
          SA1    X1SAVE            * RESTORE X1 
          EQ     C.INSRF
  
          EJECT 
*      TEMPORARY SAVE AREA
  
*      INPUT PARAMETER TEMPS
  
 INSPADDR DATA   0                 * B3 = INSPECT FIELD ADDR (MODIFIED) 
 INSPBCP  DATA   0                 * B4 = INSPECT FIELD BCP (MODIFIED)
 PARMAD   DATA   0                 * B5 = PARAMETER ADDRESS 
 PARMEND  DATA   0                 * B6 = LAST PARAMETER ADDRESS
 INSPLEN  DATA   0                 * B7 = INSPECT FIELD LENGTH
 X1SAVE   DATA   0                 * SAVED REGISTER 
  
*      MISCELLANEOUS TEMPS
  
 REPLACE  DATA   0                 * INSPECT REPLACING FLAG 
 SCANCNT  DATA   0                 * SCAN COUNT FOR INSPECT TALLYING
 TALLYCNT DATA   0                 * TALLY COUNT--MAY NOT BE NEEDED 
 BEFORTYP DATA   0                 * BEFORE/AFTER TYPE CODE FOR SIGN CON
 SAVE     BSS    4
  
          TITLE  CHARACTER STRING SCAN ROUTINE
* 
** NAME - SCANFOR 
* 
** PURPOSE
*      SCAN FOR THE FIRST OCCURRENCE OF A SHORT (1 TO 10 CHARACTERS)
*      CHARACTER STRING WITHIN ANOTHER CHARACTER STRING 
* 
** INPUT -
*         B3 = INSPECTED ITEM ADDRESS 
*         B4 = INSPECTED ITEM BCP 
*         B7 = INSPECT ITEM LENGTH
*         X3 = SCAN ITEM LENGTH (MAXIMUM 10 CHARACTERS) 
* 
** OUTPUT - 
*         X4 = COUNT OF CHARACTERS BEFORE FIRST SCAN ITEM CHARACTER 
* 
** USES - 
*         ALL X REGISTERS 
*         C.MASK
  
 SCANFOR  DATA   0
  
          SPACE  4
*      AT THIS POINT, THE INSPECT ITEM IS ALSO SET UP, IN X6, WITH
*      LEFTOVER CHARACTERS IN X2. NOW START COMPARING.
  
*      THE SCAN IS MADE BY LOADING THE INSPECT ITEM, AS THE SCAN ITEM 
*      WAS. AS EACH COMPARISON IS MADE AND FAILS, THE SCAN COUNT IS 
*      INCREMENTED, THE INSPECT ITEM IS SHIFTED LEFT ONE CHARACTER, 
*      AND ANOTHER CHARACTER IS ADDED. PERIODICALLY ANOTHER WORD OF 
*      CHARACTERS IS LOADED. INSPECTION STOPS WHEN A SUCCESSFUL FIND IS 
*      MADE OR THE REMAINING INSPECT LENGTH IS LESS THAN THE SCAN 
*      LENGTH.
  
*         B3 = INSPECT ITEM ADDRESS 
*         B4 = INSPECT ITEM BCP 
*         B5 = INSPECT ITEM LENGTH FOR DECREMENTING 
*         B6 = 6 * (10 - SCAN ITEM LENGTH)  FOR SHIFTING NEW INSPECT
*              ITEM WORD TO END OF INSPECT SECTION FOR ADDING NEW 
*              CHARACTERS.
*         B7 = INSPECT ITEM LENGTH
*         X0 = COUNT OF CHARACTERS LEFT BEFORE NEXT LOAD
*         X1 = ONE CHAR MASK ALIGNED WITH RIGHT HAND CHAR OF SCAN ITEM
*         X2 = RESERVE WORD OF INSPECT CHARACTERS, ALIGNED BY INSPECT 
*              ITEM LENGTH
*         X3 = SCAN ITEM LENGTH 
*         X4 = SCAN COUNT 
*         X5 = SCRATCH
*         X6 = INSPECT ITEM, ON A CONVEYOR BELT TO LEFT OF REGISTER 
*         X7 = SCAN ITEM
  
*      DO LOOP INITIALIZING 
  
          MX4    0                 * INITIALIZE SCAN COUNT TO 0 
  
          BX5    -X3
          SB6    X5+10             * B6 = 10 - SCAN LENGTH
          SB6    B6+B6
          SB5    B6+B6
          SB6    B5+B6             * B6 = 6 * (10 - SCAN LENGTH)
  
          MX1    6                 * X1 = ONE-CHARACTER MASK FOR GETTING
          LX1    B6,X1             * NEXT CHARACTER OF INSPECT ITEM 
          LX1    6                 * PLACE WITH LAST CHAR OF SCAN ITEM
  
          SB5    B7                * B5 = INSPECT LENGTH FOR DECREMENT
  
*      MAIN COMPARE LOOP
  
 FASTLOOP BSS    0
  
*      TEST IF SCAN ITEM LENGTH IS GREATER THAN INSPECT LENGTH LEFT 
  
          SX5    B5          INSPECT CHARACTERS LEFT
          IX5    X5-X3
          PL     X5,NOTDONE 
  
*      THERE ARE TOO FEW INSPECT ITEM CHARACTERS LEFT--A MATCH IS 
*      IMPOSSIBLE. MOVE THE INSPECT ITEM LENGTH TO THE SCAN LENGTH. 
  
          SX4    B7                * X4 = INSPECT ITEM LENGTH 
          SB5    B0                * INSPECT ITEM LENGTH = 0
          EQ     SCANFOR           * RETURN TO CALLER 
  
*      DO THE COMPARISON, EXIT IF A MATCH IS MADE.
  
 NOTDONE  BSS    0
          BX5    X6-X7             * X5 = COMPARE VALUE 
          NG     X5,NOMATCH        * NO MATCH IF NEGATIVE (FOR - 0) 
          ZR     X5,SCANFOR        * EXIT IF A MATCH IS MADE
  
*      THE COMPARISON FAILED. SHIFT INSPECT ITEM AND TRY AGAIN. 
  
 NOMATCH  BSS    0
          SX4    X4+B1             * ADD 1 TO SCAN COUNT
          SB5    B5-B1             * DECREMENT INSPECT ITEM LENGTH
  
 NOMATCH1 BSS    0
          LX6    6                 * SHIFT INSPECT ITEM LEFT ONE CHAR 
          MX5    54 
          BX6    X5*X6             * MASK OFF TOP INSPECT ITEM CHARACTER
  
*      IF THERE ARE NO MORE CHARACTERS TO ADD, GET ANOTHER WORD OF THEM.
  
          NZ     X0,MORECHAR       * BRANCH IF MORE CHARACTERS
  
          SX0    10                * 10 MORE CHARACTERS LEFT
          SA2    A2+B1             * GET NEXT WORD OF CHARACTERS
          LX2    B6,X2             * SHIFT INTO PLACE 
  
*      ADD NEXT CHARACTER TO THE INSPECT ITEM 
  
 MORECHAR BSS    0
          LX2    6                 * SHIFT NEXT CHARACTER INTO PLACE
          BX5    X1*X2             * MASK IN NEXT CHARACTER 
          BX6    X6+X5             * ADD TO INSPECT ITEM
  
          SX0    X0-1              * DECREMENT COUNT OF CHARACTERS LEFT 
          EQ     FASTLOOP          * LOOP 
  
          SPACE  4
*      THIS IS AN ALTERNATE RETURN POINT FROM THE 'TALLYING ALL'
*      AND 'TALLYING LEADING' CODE. RETURN TO THAT CODE IS VIA THE
*      NORMAL SUBROUTINE RETURN, USING THE RETURN ADDRESS FROM THE
*      RJ SCANFOR  THE FIRST TIME THIS CODE CALLS SCANFOR.
  
 TALLRETN BSS    0
  
*      INCREMENT TALLY COUNT
  
          SA5    TALLYCNT 
          SA0    X5+B1             * INCREMENT TALLY AND SAVE 
          BX5    X7                * SAVE X7 ACROSS STORE 
          SX7    A0 
          SA7    TALLYCNT          * STORE TALLY
          BX7    X5                * RESTORE X7 
  
*      THE INSPECT ITEM MUST BE COMPLETELY REPLACED. SET UP TO SHIFT THE
*      REMAINING INSPECT ITEM CHARACTERS IN X2 INTO X6 AS THE NEW 
*      INSPECT COMPARISON STRING. 
  
          IX4    X4+X3             * INCREMENT SCAN COUNT BY SCAN LENGTH
          SX5    B5 
          IX5    X5-X3             * DECREMENT INSPECT ITEM LENGTH
  
*      IF THERE ARE TOO FEW INSPECT CHARACTERS LEFT FOR A COMPARISON, 
*      LOAD THE TALLY COUNT AND RETURN TO THE CALLER OF C.INSPT.
  
          ZR     X5,TALLRET1
          PL     X5,TALLYLP5       * CONTINUE IF ENOUGH INSPECT CHARS 
  
 TALLRET1 BSS    0
          SA2    TALLYCNT          * LOAD THE TALLY COUNT 
          EQ     C.INSPTX          * RETURN TO C.INSPT CALLER 
  
 TALLYLP5 BSS    0
          SB5    X5                * SET B5 TO DECREMENTED INSPECT LENGT
          SX5    X3-1 
          ZR     X5,NOMATCH1       ONE CHARACTER SCAN ITEM
  
*      SET B6 TO THE SHIFT COUNT FOR SHIFTING NEXT SET OF INSPECT 
*      CHARACTERS IN X2 TO THE LEFT BOUNDARY OF X2. 
*      SHIFT COUNT = 6 * SCAN LENGTH. 
  
          SA0    B6                * SAVE B6
          IX5    X3+X3
          SB6    X5 
          SB6    B6+B6
          SB6    X5+B6             * B6 = 6 * SCAN LENGTH 
          LX2    B6,X2             * SHIFT CHARS TO LEFT BOUNDARY 
  
*      IF ENOUGH CHARACTERS ARE IN X2, JUST MASK THEM INTO X6, AND
*      RESUME THE SCAN. 
  
          IX5    X0-X3             * X5 = INSP CHARS LEFT - INSP LENGTH 
          NG     X5,TALLYLP2       * SKIP IF NOT ENOUGH CHARS LEFT
  
          SB6    A0                * RESTORE B6 
  
*      MASK THE NEXT SET OF INSPECT ITEM CHARACTERS INTO X6.
  
          SA5    X3+=XC.MASK        * LOAD MASK FOR INSPECT LENGTH
          BX6    X5*X2             * MASK IN INSPECT CHARACTERS 
  
          IX0    X0-X3             * X0 = INSP CHARS LEFT - INSP LENGTH 
          EQ     FASTLOOP          * LOOP 
  
          SPACE  4
*      THERE ARE NOT ENOUGH CHARACTERS IN X2. 
*      PUT THOSE LEFT IN X6, AND GET THE REST FROM THE NEXT WORD. 
  
 TALLYLP2 BSS    0
          SA5    X0+=XC.MASK       * GET MASK FOR CHARACTERS LEFT 
          BX6    X5*X2             * MASK CHARS LEFT INTO X6 LEFT ALIGNE
  
          SA2    A2+B1             * GET NEXT INSPECT WORD
  
*      SET UP SHIFT COUNT FOR SHIFTING NEXT CHARS IN X6 
  
          BX5    -X0
          SX5    X5+10
          IX5    X5+X5
          SB6    X5 
          SB6    B6+B6
          SB6    X5+B6             * B5 = 6 * (10 - CHARS IN X6)
  
*      MASK IN CHARS TO ADD TO THOSE IN X6
  
          IX5    X3-X0             * X5 = INSPECT LENGTH - CHARS IN X6
          SA5    X5+=XC.MASK       * X5 = MASK FOR ADDED CHARS
          BX5    X5*X2             * MASK IN CHARS TO ADD TO X6 
  
*      SHIFT THE CHARS AND ADD TO X6
  
          LX5    B6,X5             * SHIFT INTO PLACE 
          LX2    B6,X2             * SHIFT CHARS LEFT, CORRESPONDINGLY
          BX6    X6+X5             * ADD TO X6 TO COMPLETE INSPECT ITEM 
  
          SX0    X0+10
          IX0    X0-X3             * DECREMENT CHARS-LEFT-IN-X2 COUNT 
          SB6    A0                * RESTORE B6 
          EQ     FASTLOOP          * LOOP 
  
 SCANSET  EJECT 
* 
** NAME - SCANSET 
* 
** PURPOSE -
*      SET UP SCAN ITEM PARMETERS FOR SCANFOR, IN B5, B6, AND X3. 
*      LOAD THE SCAN ITEM AND FIRST SECTION OF THE INSPECT ITEM.
* 
** INPUT -
*         PARMAD = SCAN ITEM PRAMETERS ENCODED
* 
** OUTPUT - 
*         B5 = SCAN ITEM ADDRESS
*         X3 = SCAN ITEM LENGTH 
*         X6 = INSPECT ITEM FIRST SECTION 
*         X7 = SCAN ITEM
* 
** USES - 
*         C.MASK
*         A2,A4,A5
*         B5,B6 
*         X0,X2,X3,X4,X5,X6,X7
* 
** SAVES -
*         B3,B4,B7
  
  
          SPACE  4
 SCANSET  DATA   0
  
*      LOAD THE SCAN ITEM INTO X7, LEFT ALIGNED AND ZERO FILLED 
*      ON THE RIGHT.
  
          SA5    PARMAD 
          SA5    X5                * GET SCAN PARAMETER 
          MX3    3
          LX3    57 
          BX3    X3*X5
          AX3    54 
          SB2    X3                * TYPE 
          SB5    X5                * B5 = SCAN ITEM ADDRESS 
          LX5    42 
          SX2    X5                * X2 = SCAN ITEM OFFSET
          LX5    42 
          SX3    X5                * X3 = SCAN ITEM LENGTH
  
*      FINISH SCAN ITEM SUBSCRIPTING
  
          RJ     SRCSUBS           * SRCSUBS INPUT: B5 = ADDR, X2 = OFFS
                                   *    OUTPUT: B5 = NEW ADDR, B6 = BCP 
                                   *          USES: X2, X4, X5
  
*      GET SCAN ITEM, PUT IN X7 
  
          RJ     LOADSCAN          * INPUT: B5 = SCAN ADDR, B6 = SCAN BC
                                   *        X3 = SCAN LENGTH
                                   *       B2 = TYPE
                                   * OUTPUT: X7 = SCAN ITEM 
                                   * USES: C.MASK 
                                   *       A2,A4,A5, B5-6, X0,X2,X4,X5
                                   * SAVES: B3, B4, B7, X3
  
          SPACE  4
*      AT THIS POINT, THE SCAN ITEM IS IN X7, LEFT JUSTIFIED, 
*      AND ZERO FILLED. 
*      NOW GET THE INSPECT FIELD, AND PUT IT IN X6. 
  
          RJ     LOADINSP          * INPUT: B3 = INSP ADDR, B4 = INSP BC
                                   *        B7 = INSP LENGTH
                                   *        X3 = SCAN LENGTH
                                   * OUTPUT: X0 = CHAR COUNT BEFORE LOAD
                                   *         X2 = RESERVE WORD OF INSP
                                   *         X6 = INSP ITEM 
                                   * USES: C.MASK 
                                   *       A2,A5, B5, X0,X2,X4-6
                                   * SAVES: B3, B4, B7, X3, X7
  
          EQ     SCANSET           * RETURN TO CALLER 
  
  
          TITLE  SUBSCRIPT CALCULATION FINISH FROM B5 AND X2
** NAME - SRCSUBS 
* 
** PURPOSE
*      FINISH SUBSCRIPT CALCULATION FROM WORD ADDRESS IN B5 AND OFFSET
*      IN X2
* 
** INPUT -
*         B5 = WORD ADDRESS 
*         X2 = BYTE OFFSET
* 
** OUTPUT - 
*         B5 = NEW WORD ADDRESS 
*         B6 = BCP
* 
** USES - 
*         X2, X4, X5
  
          SPACE  4
          ENTRY  SRCSUBS
  
 SRCSUBS  DATA   0
          SX4    314632B           * X4 = (1/10)*2**20
          IX4    X4*X2             * X4 = (N/10)*2**20
          AX4    20                * X4 = N/10 = ADDRESS INCREMENT
          SB5    X4+B5             * B5 = NEW ADDRESS 
          IX5    X4+X4             * X5 = 2*(N/10)
          LX4    3                 * X4 = 8*(N/10)
          IX5    X5+X4             * X5 = 10*(N/10) 
          IX2    X2-X5             * X2 = N-10*(N/10) 
          SB6    X2                * B6 = BCP 
  
          EQ     SRCSUBS           * RETURN TO CALLER 
  
          TITLE  STRSUBS
          SPACE  4
** NAME - STRSUBS 
* 
** PURPOSE
*      FINISH SUBSCRIPT CALCULATION FROM WORD ADDRESS AND BYTE OFFSET 
* 
** INPUT -
*         B3 = WORD ADDRESS 
*         B4 = BYTE OFFSET
* 
** OUTPUT - 
*         B3 = NEW WORD ADDRESS 
*         B4 = BCP
* 
** USES - 
*         X2, X4, X5
  
          SPACE  4
          ENTRY  STRSUBS
  
 STRSUBS  DATA   0
          SX2    B4                * X2 = N 
          SX4    314632B           * X4 = (1/10)*2**20
          IX4    X4*X2             * X4 = (N/10)*2**20
          AX4    20                * X4 = N/10 = ADDRESS INCREMENT
          ZR     X4,STRSUBS        * EXIT IF BCP ONLY, IN B4
          SB3    X4+B3             * B3 = NEW ADDRESS 
          IX5    X4+X4             * X5 = 2*(N/10)
          LX4    3                 * X4 = 8*(N/10)
          IX5    X5+X4             * X5 = 10*(N/10) 
          IX2    X2-X5             * X2 = N-10*(N/10) 
          SB4    X2                * B4 = BCP 
          EQ     STRSUBS
  
 STORREPL EJECT 
* 
** NAME - STORREPL
* 
** PURPOSE -
*      STORE THE REPLACE ITEM IN AN INSPECT REPLACING STATEMENT.
*      THE REPLACE ITEM MUST FIT IN ONE OR TWO WORDS. 
*      THE INSPECT ITEM DESCRIPTION IS ALSO UPDATED.
* 
** INPUT -
*         B3 = INSPECT ITEM ADDRESS 
*         B4 = INSPECT ITEM BCP 
*         B7 = INSPECT ITEM LENGTH
*         X3 = SCAN AND REPLACE ITEM LENGTH 
*         X4 = SCAN COUNT OFFSET FROM START OF INSPECT ITEM 
*         PARMEND = ENCODED REPLACE ITEM PARAMETER ADDRESS
* 
** OUTPUT - 
*         B3 = UPDATED INSPECT ITEM ADDRESS 
*         B4 = UPDATED INSPECT ITEM BCP 
*         B7 = UPDATED INSPECT ITEM LENGTH
*         REPLACE ITEM IS STORED INTO INSPECT ITEM
* 
** USES - 
*         A0,A2,A5,A6,A7
*         B3,B4,B5,B6,B7
*         X0,X2,X4,X5,X6,X7 
  
 STORREPL DATA   0
  
*      DECREMENT INSPECT ITEM LENGTH BY SCAN COUNT AND REPLACE ITEM 
*      LENGTH.
  
          IX5    X3+X4             * X5 = SCAN COUNT + REPLACE LENGTH 
          SB5    X5 
          SB7    B7-B5             * B7 = INSP LEN - SCAN CNT - REPL LEN
  
*      UPDATE INSPECT ITEM ADDRESS AND BCP TO POINT TO REPLACE ITEM.
  
  
          SB4    X4+B4
  
          RJ     STRSUBS           * STRSUBS INPUT: B3 = ADDR, B4 = OFFS
                                   *    OUTPUT: B3 = NEW ADDR, B4 = BCP 
                                   *          USES: X2, X4, X5
  
*      SET UP FOR LOADING THE REPLACE ITEM INTO X7
  
          SA5    PARMEND
          SA5    X5                * GET REPLACE PARAMETER
          MX4    3
          LX4    57 
          BX4    X4*X5
          AX4    54 
          SB2    X4                * TYPE 
          SB5    X5                * B5 = REPLACE ITEM ADDRESS
          LX5    42 
          SX2    X5                * X2 = REPLACE ITEM OFFSET 
  
*      FINISH REPLACE ITEM SUBSCRIPTING 
  
          RJ     SRCSUBS           * SRCSUBS INPUT: B5 = ADDR, X2 = OFFS
                                   *    OUTPUT: B5 = NEW ADDR, B6 = BCP 
                                   *          USES: X2, X4, X5
  
*      LOAD THE REPLACE ITEM INTO X7
  
          RJ     LOADSCAN          * INPUT: B5 = SCAN ADDR, B6 = SCAN BC
                                   *        X3 = SCAN LENGTH
                                   *       B2 = TYPE
                                   * OUTPUT: X7 = SCAN ITEM 
                                   * USES: C.MASK 
                                   *       A2,A4,A5, B5-6, X0,X2,X4,X5
                                   * SAVES: B3, B4, B7, X3
  
*      STORE THE REPLACE ITEM INTO THE INSPECT ITEM.
  
          SA2    B3                * GET FIRST WORD OF INSPECT ITEM 
  
*      COMPUTE 6 * (10 - INSPECT BCP) FOR SHIFTING REPLACE ITEM 
*      INTO POSITION. 
  
          SX0    B4-10
          BX0    -X0               * X0 = 10 - INSPECT ITEM BCP 
          SB5    X0 
          SB5    B5+B5
          SB6    B5+B5
          SB6    B5+B6             * B6 = 6 * (10 - INSPECT BCP)
  
*      SHIFT THE REPLACE ITEM INTO POSITION IN THE INSPECT WORD(S)
  
          LX7    B6,X7
  
*      TEST WHETHER THIS IS A ONE-WORD OR TWO-WORD REPLCEMENT.
*      IF  BCP + LENGTH LE 10  THIS IS A ONE-WORD REPLACEMENT.
  
          IX4    X0-X3             * X4 = 10 - BCP - LENGTH 
          PL     X4,ONEREPL        * BRANCH IF ONE-WORD REPLACE 
  
*      THIS IS A TWO-WORD REPLACEMENT.
  
          SA5    B4+=XC.MASK       * GET MASK ON REPLACE BCP
          BX2    X5*X2             * SAVE NEEDED FIRST WORD CHARS 
          BX6    -X5*X7            * EXTRACT FIRST WORD REPLACE CHARS 
          BX6    X2+X6             * PUT REPLACED FIRST WORD TOGETHER 
          SA6    A2                * STORE FIRST WORD 
  
          BX4    -X4
          SA5    X4+=XC.MASK       * GET MASK FOR SECOND WORD REPLACEMEN
  
          SA2    A2+B1             * GET SECOND WORD
          BX2    -X5*X2            * SAVE NEEDED SECOND WORD CHARS
          BX7    X5*X7             * EXTRACT SECOND WORD REPLACE CHARS
          BX7    X2+X7             * PUT REPLACED SECOND WORD TOGETHER
          SA7    A2                * STORE SECOND WORD
          SB4    X3+B4       INSPECT BCP + REPLACE SIZE 
          RJ     STRSUBS
  
          EQ     STORREPL          * RETURN TO CALLER 
  
*      THIS IS A ONE-WORD REPLACEMENT 
  
 ONEREPL  BSS    0
          SA5    X3+=XC.MASK       * GET MASK ON REPLACE LENGTH 
          LX5    B6,X5             * SHIFT INTO PLACE IN WORD 
          BX4    -X5*X2            * SAVE NEEDED CHARS IN WORD
          BX7    X5*X7             * EXTRACT REPLACE CHARS
          BX7    X4+X7             * PUT REPLACED WORD TOGETHER 
          SA7    A2                * STORE REPLACED WORD
  
*      INCREMENT INSPECT ITEM ADDRESS BY REPLACE LENGTH, SO THE^
*      NEXT REPLACEMENT SCAN WILL START IN THE RIGHT PLACE. 
  
          SB4    X3+B4             * B4 = INSPECT BCP + REPLACE LENGTH
  
          RJ     STRSUBS           * STRSUBS INPUT: B3 = ADDR, B4 = OFFS
                                   *    OUTPUT: B3 = NEW ADDR, B4 = BCP 
                                   *          USES: X2, X4, X5
  
          EQ     STORREPL          * RETURN TO CALLER 
  
          EJECT 
* 
** NAME - LOADSCAN
* 
** PURPOSE
*      LOAD SCAN ITEM INTO X7 FOR COMPARISON WITH INSPECT ITEM
* 
** INPUT -
*         B2 = SCAN ITEM TYPE 
*         B5 = SCAN ITEM ADDRESS
*         B6 = SCAN ITEM BCP
*         X3 = SCAN ITEM LENGTH 
* 
** OUTPUT - 
*         X7 = SCAN ITEM
* 
** SAVES -
*         B3, B4, B7
*         X3
  
          SPACE  4
 LOADSCAN DATA   0
          NE     B2,B0,LOADSNUM 
          SA2    B5                * GET FIRST WORD OF SCAN ITEM
  
*      COMPUTE BCP * 6 FOR LEFT SHIFT COUNT AND LEFT ALIGN SCAN ITEM
  
          SX0    B6                * SAVE SCAN ITEM BCP 
          SB5    B6+B6             * B5 = BCP * 2 
          SB6    B5+B5             * B6 = BCP * 4 
          SB6    B6+B5             * B6 = BCP * 6 
  
          LX2    B6,X2             * SHIFT SCAN ITEM TO LEFT BOUNDARY 
  
*      TEST WHETHER THIS IS A ONE-WORD OR TWO-WORD ITEM.
*      IF BCP + LENGTH LE 10  THIS IS A ONE-WORD ITEM.
  
          SX4    X0-10             * X4 = BCP - 10
          BX4    -X4               * X4 = 10 - BCP
          SA5    X4+=XC.MASK       * GET MASK FOR SCAN ITEM BCP, IF 
                                   * NEEDED 
          IX4    X4-X3             * X4 = 10 - BCP - LENGTH 
          PL     X4,ONESCAN        * BRANCH IF ONE-WORD SCAN ITEM 
  
*      THIS IS A TWO-WORD SCAN ITEM.
  
          BX2    X5*X2             * EVICT UNWANTED FIRST WORD CHARS
          BX4    -X4
          SA5    X4+=XC.MASK       * GET SECOND WORD MASK 
  
          SA4    A2+B1             * GET SECOND WORD
          BX4    X5*X4             * EVICT UNWANTED SECOND WORD CHARS 
          LX4    B6,X4             * SHIFT SECOND WORD INTO PLACE 
          BX7    X2+X4             * PUT FIRST AND SECOND WORD TOGETHER 
  
          EQ     LOADSCAN          * RETURN TO CALLER 
  
*      THIS IS A ONE-WORD SCAN ITEM.
  
 ONESCAN  BSS    0
          SA1    X3+=XC.MASK       * GET MASK BASED ON LENGTH 
          BX7    X1*X2             * PUT SCAN ITEM IN X7
  
  
          EQ     LOADSCAN          * RETURN TO CALLER 
  
 LOADSNUM BSS    0           SIGN OVERPUNCH 
*      SAVE REGS
          SX7    B3 
          SA7    SAVE 
          SX7    B7 
          SA7    A7+B1
          SX7    B4 
          SA7    A7+B1
          SX7    X3 
          SA7    A7+B1
          SX1    B6          OFFSET 
          SB3    B5          ADDRESS
          BX0    X3 
          MX3    1
          LX3    6
          BX0    X0+X3       SIGNED SOURCE
          LX3    12 
          BX0    X0+X3       NO SHIFT 
          MX3    1
          LX3    1
          SX7    B2 
          BX3    X7*X3       LEADING OVERPUNCH
          LX3    7
          BX0    X0+X3
          RJ     =XC.ND2RN
          SA3    SAVE+3      SCAN LENGTH
          SB5    10 
          SB6    X3 
          SB5    B5-B6       10-LENGTH
          SB6    B5+B5
          SB5    B6+B6
          SB6    B6+B5
          LX7    B6,X2       SHIFT LEFT 
          SA1    =XC.MASK+X3
          BX7    X1*X7       ZERO FILL
*      RESTORE REGISTERS
          SA1    SAVE 
          SB3    X1 
          SA1    A1+B1
          SB7    X1 
          SA1    A1+B1
          SB4    X1 
          EQ     LOADSCAN 
          EJECT 
* 
** NAME - LOADINSP
* 
** PURPOSE
*      LOAD INSPECT ITEM SUBSTRING INTO X6 FOR COMPARISON WITH SCAN ITEM
* 
** INPUT -
*         B3 = INSPECT ITEM ADDRESS 
*         B4 = INSPECT ITEM BCP 
*         B7 = INSPECT ITEM LENGTH
*         X3 = SCAN ITEM LENGTH 
* 
** OUTPUT - 
*         X0 = COUNT OF INSPECT CHARACTERS LEFT BEFORE NEXT LOAD
*         X2 = RESERVE WORD OF INSPECT CHARACTERS 
*         X6 = INSPECT ITEM 
* 
** USES - 
*         C.MASK
*         A2, A5
*         B5, B6
*         X0, X2, X4, X5, X6
* 
** SAVES -
*         B3, B4, B7
*         X3, X7
  
          SPACE  4
 LOADINSP DATA   0
  
*      PUT THE INSPECT ITEM SUBSTRING LENGTH IN B6. 
*      IF THE INSPECT ITEM IS AT LEAST AS LONG AS THE SCAN ITEM (THE
*      NORMAL CASE), USE THE SCAN LENGTH. 
*      IF NOT, USE THE INSPECT ITEM LENGTH. 
  
          SB6    X3                * B6 = SCAN ITEM LENGTH
                                   * B7 = INSPECT ITEM LENGTH 
          GE     B7,B6,USESCAN     * BRANCH IF INSP LEN AT LEAST SCAN LN
  
          SB6    B7                * B6 = INSPECT ITEM LENGTH 
 USESCAN  BSS    0
  
          SA5    B3                * GET FIRST WORD OF INSPECT ITEM 
  
*      COMPUTE BCP * 6 FOR LEFT SHIFT COUNT AND LEFT ALIGN INSPECT ITEM 
  
          SB5    B4+B4             * B5 = BCP * 2 
          SX6    B5+B5             * X6 = BCP * 4 
          SB5    X6+B5             * B5 = BCP * 6 
  
          LX5    B5,X5             * SHIFT INSPECT ITEM TO LEFT BOUNDARY
  
*      TEST WHETHER THIS IS A ONE-WORD OR TWO-WORD ITEM.
*      IF BCP + LENGTH LE 10  THIS IS A ONE-WORD ITEM 
  
          SX0    B4-10             * X0 = BCP - 10
          SX6    B0-B6             * X6 = - LENGTH
          IX0    X6-X0             * X0 = 10 - BCP - LENGTH 
          PL     X0,ONESCANI       * BRANCH IF ONE-WORD SCAN ITEM 
  
*      THIS IS A TWO-WORD SCAN ITEM 
  
          SB6    X0+B6             * 10 - BCP 
          SA2    B6+=XC.MASK
          BX5    X5*X2             * EVICT UNWANTED FIRST WORD CHARS
          BX4    -X0               * X4 = BCP + LENGTH - 10 
          SA4    X4+=XC.MASK       * MASK FOR SECOND WORD 
  
          SA2    A5+B1             * GET SECOND WORD
          BX4    X2*X4             * EVICT UNWANTED SECOND WORD CHARS 
          LX4    B5,X4             * SHIFT SECOND WORD INTO PLACE 
          LX2    B5,X2             * SHIFT UNMASKED SECOND WORD 
          BX6    X4+X5             * PUT FIRST AND SECOND WORD TOGETHER 
  
*      SET UP COUNT OF CHARACTERS LEFT IN X2 BEFORE NEEDING A LOAD
  
          SX0    X0+10             * X0 = COUNT OF CHARS BEFORE LOAD
          EQ     LOADINSP          * RETURN TO CALLER 
  
*      THIS IS A ONE-WORD SCAN ITEM.
  
 ONESCANI BSS    0
          SA4    B6+=XC.MASK       * GET MASK BASED ON LENGTH 
          BX6    X5*X4             * PUT INSPECT ITEM IN X6 
          SA2    A5                * RESERVE INSPECT CHARACTERS 
          BX2    X5                * SHIFTED CHARACTERS 
  
          EQ     LOADINSP          * RETURN TO CALLER 
  
          END 
