ASMB,R,N
*                                         <800822.0734> 
* 
* 
*  ***************************************************************
*  * (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1980.  ALL RIGHTS     *
*  * RESERVED.  NO PART OF THIS PROGRAM MAY BE PHOTOCOPIED,      *
*  * REPRODUCED OR TRANSLATED TO ANOTHER PROGRAM LANGUAGE WITHOUT*
*  * THE PRIOR WRITTEN CONSENT OF HEWLETT-PACKARD COMPANY.       *
*  ***************************************************************
* 
* 
*           NAME:   EDIT2 
*           SOURCE: 92074-18007 
*           RELOC:  PART OF 92074-12001 
*           PGMR:   J.D.J.
* 
* 
*                                         <800822.0734> 
      NAM EDIT2,5,51 92074-1X007 REV.2034 800818
      ENT EDIT2 
      ENT ED%.B     B COMMNAD 
      ENT ED%.F     F COMMAND 
      ENT ED%.D     D COMMAND 
      ENT ED%.X     EXCAHNGE COMMNADS 
      ENT ED%XU     DO SUBITUTE 
      ENT ED%FS     FORWARD SCAN  SPEC
      ENT ED%BS     BACKWARD SCAN SPEC
      ENT ED%S1     SEARCH FOR LINE SPEC 1
      ENT ED%S2     SEARCH FOR LINE SPEC 2
      ENT ERTN     ERROR RETURN 
      ENT FDCNT    MATCH COUNT  
      ENT SXFLG    SINGLE EXCHANGE  FLAG
* 
* 
      IFZ 
      EXT EXEC
      XIF 
* 
* JUMP POINTS IN MAIN 
* 
* 
      EXT .EOF1     DO END OF FILE STUFF
      EXT DISPL 
      EXT EOFPR     PRINT EOF 
      EXT L1ERR 
      EXT L2ERR 
      EXT .UNDO     UNDO COMMAND
      EXT OFFSP     GO GET LINE OFFSET SPECS
      EXT NODE1     DO NEXT COMMAND 
* 
* SUBROUTINE IN MAIN
* 
* 
      EXT ASCII     TEST IF DIGIT 
      EXT ASK       ASK BEFORE EXCUTION 
      EXT SETOK 
      EXT ./B1      ROLL TO TOP OF FILE 
      EXT CSTRP     STRIP COMMANS 
      EXT DFL1S 
      EXT ECHL
      EXT ECH 
      EXT FLLER     COPY NEXT FILED FOR RBUFF TO E BUFF 
      EXT GETL2     GET LIN SPEC 2
      EXT I/PSB     INPUT NEXT SOURCE LINE
      EXT LST       LIST SUBROUTINE 
      EXT LSTSB     LIST SOURCE BUFFER
      EXT PBKE      PUT BACK COMMAND CHAR 
      EXT PRINT 
      EXT PUNCT 
      EXT PSL1      POSITION AT LINE SPEC 1 
      EXT PSLN      POSITION SOURCE TO  LINE N
      EXT RPRTW     REPORT WINDOW 
      EXT ROLLN     ROLL TO LINE N
      EXT SCH       GET NEXT SOURCE LINE CHAR 
      EXT SETMS     SET DELETED FLAG IN FOLLC 
      EXT TR        TRANSFER A LINE 
      EXT TRN       TRANSFER N LINES
      EXT LCASE     FOLD CASE 
      EXT OUTCR     PUT CHAR IN TBUFF 
      EXT ./R$      REPLACE SOURCE LINE 
      EXT UNDOD     SET UP TO UNDO A DELETE 
* 
* 
* DATA IN MAIN
* 
      EXT ALLFG     ALL OPTION FLAG 
      EXT ANCCH     ANCHOR CJARACTER
      EXT BAR       COMMAND SEPERATOR 
      EXT BKRTN     RETURN FOR TR AT P+2 IF BREAK FLAG
      EXT COMND     CURRENT COMAND
      EXT DLMTR 
      EXT ECCNT     E BUFFER COUNT
      EXT ELNG      E BUFFER LENGTH 
      EXT ESCCH     ESCAPE CHAR 
      EXT EXFLG     EXCHANGE FLAG 
      EXT EBUFF     COMMAND BUFFER
      EXT FBUF0     FIND BUFFER 
      EXT FBUFF      POINTER TO FIND BUFFER 
      EXT FILLC     FILL CHARS ON LIST
      EXT FOLDF     CASE FOLD FLAG
      EXT FDFLG     CASE FOLD FLAG 10000=> DON'T FOLD 0=> FOLD
      EXT FLNG      FBUFF LENGTH
      EXT FRTNF     FIND RETURN FLAG
      EXT INDEF     INDEFINATE CHAR 
      EXT L1FLG     LINE SPEC 1 FLAG
      EXT L1PAT     L1 PATTERN GIVEN FLAG 
      EXT L1GIV     L1 SECP GIVEN 
      EXT L1LIN     LINE SPEC 1 LINE
      EXT L2FLG     LINE SPEC 2 FLAG
      EXT L2PAT     LINE 2 PATTERN GIVEN
      EXT L2LIN     LINE 2 LINE 
      EXT LINES 
      EXT LSTFG     LIST FLAG 
      EXT MAX       MAX BUFFER SIZE IN BYTES
      EXT NLFLG     NUMBERED LIST FLAG
      EXT NWFLG     NO WINDOW FLAG
      EXT NFNDF     LINE SPEC NOT FOUND FLAG
      EXT QUFLG     QUTIE FLAG
      EXT PATCH     FLAG IF THERE IS MORE DATA IN RBUFF 
      EXT REFLG     REGULAR EXPERSSION FLAG 
      EXT REVFG     REVERSE FLAG
      EXT RTNFG     RETURN FLAG 
      EXT R$FLG     CURRENT LINE HAS BEEN CHANGED FLAG
      EXT SCCNT     SOURCE LINE COUNT 
      EXT SBUFP     SOURCE LINE POINTER 
      EXT SLNG      SOURCE LINE LENGTH
      EXT T#REC     DECT RECORD NUMBER
      EXT TRFLG     TRANSFER FLAG 
      EXT UNCON     UNCONDITIONAL FLAG
      EXT WIND1     WINDOW
      EXT WIND2       COLUMNS 
      EXT XLNG
      EXT XYBUF 
      EXT YOFFS 
      EXT YLNG
      EXT ZRMVF     ZERO LENGTH REMOVE FLAG 
      EXT OCCNT       CURRENT TBUFF COUNT 
      EXT MTCH      SUCCESSFUL MATCH FLAG 
* 
      EXT MATCH,GETPT,GETSB,CHANG 
* 
      EXT .ENTR,.MVW,.SBT,.LBT,.MBT,.XFER 
      EXT CNUMD 
* 
      EXT SRTN
      EXT ERR 
* 
A     EQU 0 
B     EQU 1 
* 
******************************
* 
*  THERE ARE THREE SETS OF MATCH BUFFERS AND ONE SUBITUTE BUFFER
*    LINE1 SPEC, LINE 2 SPEC AND FIND ALL HAVE THERE OWN BUFFERS
*       (L1REB)     (L2REB)        (FREB0)
*    THIS ALLOWS THE MATCH FILED TO BE BUILT BEFORE ANY SEARCHING 
*     IS DONE.
* 
*     SUBITUTE ( X COMMNAD) USES THE FIND BUFFERS FOR THE MATCH PORTIONS
*     AND HAS IT'S OWN SUBITUTE BUFFER (RXSUB). 
* 
*     THERE IS A TEMP BUFFER (LBUF0) USED FOR UNPACKING 
*     AND ANOTHER (STBF0) USED FOR PACKING
* 
*  !  SUBITUTE ALSO NEEDS ANOTHER BUFFER FOR THE UNFOLDED STRINGS  !
*  !   SO IT USES THE L2 SPEC BUFFER .                             !
* 
L1REB BSS 152       LINE SPEC 1 RE BUFFER 
L1REP BSS 76        LINE SPEC 1 POSSIBLE MATCH BUFFER 
L1REL BSS 1           IT'S LENGTH 
L2REB BSS 152       LINE SPEC 2 RE BUFFER 
L2REP BSS 76        LINE SPEC 2 POSSILBE MATCH BUFFER 
L2REL BSS 1          IT'S LENGTH
FREB0 BSS 152       FIND COMMAND RE BUFFER
FPBF0 BSS 76        FIND COMMAND POSSIBLE MATCH BUFFER
FPLNG BSS 1           IT'S LENGTH 
RXSUB BSS 152       SUBITUTE FIELD BUFFER 
* 
LBUF0 BSS 152       TEMP BUFFER USED IN UNPACKING 
STBF0 BSS 152       TEMP BUFFER USED FOR PACKING
LBUFF DEF LBUF0 
STBUF DEF STBF0 
* 
* 
EOS   DEC -2        RATFOR END OF STRING CHARACTER
NEWLI DEC 13        CARRAGE RETURN
M2    DEC -2
ZERO  DEC 0 
.1    DEC 1 
.2    DEC 2 
.150  DEC 150 
RSS   RSS           USED AS DATA DURING INSTRUCTION PATCHING
* 
FOLDS BSS 1         FOLD FLAG SAVED HERE
TEMP  BSS 1 
T1    BSS 1 
T2    BSS 1 
TEMP1 BSS 1 
TEMP2 BSS 1 
************************
* 
EDIT2 JMP SRTN      JUMP BACK TO MAIN 
* 
* 
******************************
ERTN   NOP           FTN4 MOUDULE MAY CALL TO HERE
      JMP ERR        JUST GIVE UP 
* 
***************** 
* 
*  UNPK - UNPACK FROM BUFFER INTO LBUFF - ADD EOS 
*     DO CASE FOLDING IF NEEDED 
*     A REG  - LENGTH OF BUFFER 
*     B REG  - BYTE ADDRESS 
* 
* 
UNPK  NOP 
      STA TEMP      SAVE A REG ( LENGTH ) 
      LDA LBUFF     USE LINE BUFFER TO UNPACK PATTERN 
      STA TEMP1      INITALIZE CURRENT POINTER INTO LINE BUF
      LDA TEMP      GET BACK LENGTH 
      CMA,INA,SZA,RSS MAKE LENGTH INTO A LOOP COUNT 
      JMP UNPK2        ZERO LENGTH LINE 
      STA TEMP
      LDA FOLDF     GET FOLDF 
      SZA           TEST IF WER SHOULD FOLD 
      CLA,RSS         YES - PATCH IN A NOP BEFORE JSB LCASE 
      LDA RSS         NO  - PATCH IN A SKIP BEFORE JSB LCASE
      STA CPTCH     SET INSTRUCTION 
UNPK1 JSB .LBT      GET CHAR
      STB TEMP2     SAVE ADDRESS
CPTCH   BSS 1         THIS INSTRUCTION IS PATCHED IN
      JSB LCASE           GO CASE FOLD
      STA TEMP1,I   SAVE IT IN UNPACKED LINE BUFFER 
      LDB TEMP2     GET BACK BYTE ADDRESS 
      ISZ TEMP1     BUMP POINTER
      ISZ TEMP      CHECK LOOP COUNT
      JMP UNPK1       MORE CHAR - CONTINUE LOOP 
* 
UNPK2 LDA EOS       PUT END OF STRING 
      STA TEMP1,I     AT END OF LBUF
      JMP UNPK,I    RETURN
* 
* 
***************************************** 
* 
*  MKPAT - MAKE FIND PATTERN FROM EBUFF.
*           DELIMITER IS IN PDLIM 
* 
MKP.T BSS 1 
* 
MKFRM BSS 1         SOURCE OF PATTERN 
MKFLN BSS 1         IT'S LENGTH 
MKUTO BSS 1         WERE TO PUT UNPACKED PATTERN
MKPTO BSS 1         WERE TO PUT PACKED POSSIBLE PATTERN 
MKL   BSS 1           LENGTH
MKPAT NOP 
      JSB .ENTR 
        DEF MKFRM 
      LDA MKFLN,I   GET LENGTH
      LDB MKFRM     AND POINTER 
      CLE,ELB         MAKE IT A BYTE POINTER
      JSB UNPK      GO UNPACK AND ADD EOS 
      JSB GETPT      RAT4 SUBROUTINE TO GET PATTERN 
        DEF MKPT1 
        DEF LBUF0   UNPACKED SOURCE 
        DEF MKUTO,I UNPACKED PATTERN
        DEF STBF0   UNPACKED POSSIBLE MATCH 
        DEF .150    MAX PATTERN LENGTH
MKPT1 EQU * 
      SSA           TEST FOR ERROR
      JMP MKPAT,I   YES 
      STA MKP.T 
      LDA STBUF     GET ADDRESS OF UNPACKED POSSIBLE MATCH
      STA TEMP        AND SET AS SOURCE ADDRESS IN PACK LOOP. 
      LDA MKPTO     GET WORD ADDRESS OF DEST OF POSSIBLE MATCH
      CLE,ELA       MAKE IT BYTE ADDRESS
      STA TEMP1       AND SET AS DEST. BYTE IN PACK LOOP
      ADA MAX       BUMP TO MAX CHAR COUNT
      STA TEMP2     SET AS LIMIT
      CLA 
      STA MKL,I     CLEAR LENGTH
PCK$1 LDA TEMP,I     GET CHAR 
      CPA EOS         DONE ?
      JMP PCK$3         YES - BREAK LOOP
      CPA NEWLI       IS IT A NEWLINE CHAR
      JMP PCK$2         YES - SKIP IT 
      LDB FOLDF     SHOULD WE 
      SSB              FOLD ? 
      JSB LCASE        YES - GO DO IT 
      ISZ MKL,I     BUMP LENGTH 
      LDB TEMP1     GET BYTE ADDRESS
      JSB .SBT      PUT BYTE THERE
      STB TEMP1     SAVE TILL NEXT TIME 
      CPB TEMP2     DID WE REACH THE LIMIT ?
      JMP PCK$3      YES - STOP PACKING 
PCK$2 ISZ TEMP      BUMP UNPACKED POINTER 
      JMP PCK$1       LOOP
* 
PCK$3 EQU * 
      LDA MKP.T     GET STATUS
      JMP MKPAT,I   RETURN
* 
* 
********************
* 
* UNPKS - UNPACK FOLDED SOURCE BUFFER INTO LBUFF- ADD NEWLINE AND EOS.
*         UNPACK ONLY CHAR WITHIN THE WINDOW IF ENABLED 
* 
* 
* 
UNPKS NOP 
      LDB NWFLG      TEST IF WINDOW IS TURNED OFF 
      LDA WIND1     GET START OF WINDOW 
      SSA 
      CLA           WINDOW TURNED OFF - USE ZERO AS START 
      STA SCCNT 
      LDA WIND2     COMPUTE MAX NUMBER OF CHAR  
      ADA WIND1       TO UNPACK 
      SSB           TEST IF WINDOW IS DISABLED  
      CLA              YES - ALLOW 64K CHAR 
      STA PCK.T 
      LDA LBUFF     FOLDED UNPACK SOURCE LINE 
      STA TEMP       SET POINTER TO START OF BUFFER 
      LDA STBUF     UNFOLDED UNPACKED SOURCE LINE 
      STA TEMP1        ( NEEDED FOR SUBITUTE )
      LDA FOLDF     GET FOLD FLAG 
      SZA           TEST IF WE SHOULD FOLD
      CLA,RSS         YES - PATCH IN A NOP BEFORE JSB LCASE 
      LDA RSS         NO  - PATCH IN A SKIP BEFORE JSB LCASE
      STA SPTCH     SET INSTRUCTION 
UNPS1 JSB SCH       GET NEXT SOURCE CHAR
      JMP UNPS2     LAST ONE SO BREAK UNPACK LOOP 
      STA TEMP1,I    PUT CHAR IN UNFOLD BUFFER
      ISZ TEMP1 
SPTCH BSS 1         NOP/RSS PATCHED IN HER FOR FOLD/ON FOLD 
      JSB LCASE      YES - FOLD THE CHARACTER 
      STA TEMP,I    PUT UNPACKED CHAR IN LINE BUFFER
      ISZ TEMP      BUMP POINTER
      ISZ PCK.T     TEST IF WE MOVED ALL CHAR IN WINDOW 
      JMP UNPS1       NO - LOOP FOR NEXT SOURCE CHAR
UNPS2 LDA NEWLI     PUT A NEWLINE CHARACTER IN
      STA TEMP1,I 
      ISZ TEMP1 
      STA TEMP,I
      ISZ TEMP
      LDA EOS       PUT END OF STRING TERMINATOR IN.
      STA TEMP1,I 
      STA TEMP,I
      JMP UNPKS,I   RETURN
* 
* 
**********************************
* 
*  BUILD XR PATTERN AND SUBSITUTE PATTERN 
*     JSB QXPAT 
*     JMP ERR       ERROR RETURN
*     NOP           GOOD RETURN 
* 
XRBUF BSS 1         POINTER TO X BUFFER 
YROFF BSS 1         NUMBER OF BYTE TO GET TO SUBITUTE PATTERN 
YRLNG BSS 1         SUBITUTE PATTERN LENGTH 
XRSUB NOP 
      JSB .ENTR 
        DEF XRBUF 
* 
*  MAKE SUBSITUTE PATTERN 
* 
* 
.QX.5 LDA FOLDF     SAVE FOLD FLAG
      STA FOLDS 
      CLA            CLEAR IT BECASUE WE DO NOT WANT TO FOLD SUB
      STA FOLDF 
      LDA YRLNG,I   GET LENGTH
      LDB XRBUF     GET START OF BUFFER 
      CLE,ELB       MAKE IT BYTE ADDRESS
      ADB YROFF,I   BUMP TO WHERE Y BUFFER STARTS 
      JSB UNPK        UNPACK INPUT CHARS
      LDA FOLDS      RESTORE FOLD FLAG
      STA FOLDF 
      JSB GETSB       GO BUILD SUBITUTE IN RAT4 
        DEF MKSB1 
        DEF LBUF0   UNPACKED  SOURCE
        DEF RXSUB   RETURNED UNPACKED SUBITIUE FILED
        DEF .150      MAX SUB BUFF
MKSB1 EQU * 
* 
      JMP XRSUB,I   RETURN
* 
* 
*************************************** 
* 
*   PCK - PACKS BUFFER POINTED TO BY A REG. INTO TBUFF
*     ENDS WITH A EOS, NEWLINES ARE STRIPED.
*     CHAR BEFORE AND AFTER WINDOW ARE PACKED INTO TBUFF
*     IF THE WINDOW IS ENABLED
* 
* 
PCK   NOP 
      STA PCK.T 
      JSB XWBFR       GO MOVE ANY CHAR BEFORE WINDOW INTO TBUFF 
PCK.1 LDA PCK.T,I     GET CHAR
      CPA EOS         DONE ?
      JMP PCK.3         YES - RETURN
      CPA NEWLI       IS IT A NEWLINE CHAR
      JMP PCK.2         YES - SKIP IT 
      JSB OUTCR       PUT CHAR IN TBUFF 
PCK.2 ISZ PCK.T 
      JMP PCK.1       LOOP
* 
PCK.3 JSB XWAFT     GO MOVE CHAR AFTER WINDOW 
      JMP PCK,I     RETURN  
* 
*       
PCK.T BSS 1 
************************************************
* 
*  XWBFR       MOVE ANY CHARS BEFORE WINDOW IN SBUFF TO TBUFF 
*       
XWBFR NOP 
      CLA             CLEAR 
      STA OCCNT         OUTPUT BUFFER 
      STA SCCNT 
      LDB NWFLG       IF WINDOW IS
      SSB               OFF THEN
      JMP XWBF9           JUST RETURN.
      LDA WIND1     GET WINDOW START COLUMN 
      CMA,INA,SZA,RSS MAKE IT A LOOP COUNT
      JMP XWBF9     NONE SO RETURN
      STA TEMP
XWBF0 JSB SCH 
       JMP XWBF9    END OF SOURCE HIT - RETURN
      JSB OUTCR 
      ISZ TEMP
      JMP XWBF0 
XWBF9 JMP XWBFR,I   ALL COPIED - RETURN 
* 
********************************************* 
* 
*     MOVE CHAR AFTER WIND TO TBUFF 
* 
XWAFT NOP                                                                     
      LDB NWFLG 
      SSB 
      JMP XWAFT,I   WINDOW OFF SO RETURN NOW
      LDB WIND2 
      LDA B 
      ADA SLNG      IS END OF LINE BEFORE 
      SSA              WINDOW ? 
      JMP XWAFT,I       YES - RETURN
      CMB,INB       MAKE WIDOW LIMIT POSITIVE 
      STB SCCNT      AND SET AS SOURCE COUNT
XWAF1 JSB SCH 
       JMP PCK,I    LAST CHAR FOUND SO RETURN 
      JSB OUTCR 
      JMP XWAF1     LOOP FOR NEXT CHAR
      JMP XWAFT,I   CHAR ALL MOVED - RETURN 
************************* 
* 
* 
RMTCH NOP           TEST IF RE MATCHES SOURCE LINE
      STA RMTHB     SET BUFFER ADDRESS
      JSB UNPKS     UNPACK INTO LBUFF (USE UNPKS SO NEWLINE IS ADDED) 
      IFZ 
      JSB EXEC      PRINT OUT SOME TO SHOW POSSIBLE MATCH 
      DEF TSTRT 
      DEF .2
      DEF .1
      DEF "._"
      DEF .1
TSTRT EQU * 
      XIF 
      JSB MATCH     GO TRY FOR MATCH
        DEF QF.2
        DEF LBUF0 
RMTHB   DEF *       MATCH BUFFER PATCHED IN HERE
QF.2  SZA           IF ZERO THEN NO MATCH 
      ISZ RMTCH       MATCH - BUMP RETURN 
      IFZ 
      JSB EXEC      FOUND - SEND CRLF 
      DEF QF.5
      DEF .2
      DEF .1
      DEF SPSP
      DEF .1
QF.5  EQU * 
      XIF 
      JMP RMTCH,I   RETURN
* 
************************* 
* 
*  QX DOES EXCHANGES - PUTS RESULT IN SOURCE BUFF 
******************* 
* SPECIAL CALLING CONDITIONS: 
* 
*   MATCH BUFFER IS IN FREB0
*   MBUFF POINTS TO POSSIBLE MATCH
*   MLNG    IS POSSIBLE MATCH LENGTH
* 
XRE   NOP 
      JSB COMPL     TEST IF CHANGE IS POSSIBLE
        JMP XRE,I     NO - RETURN (MBUFF MUST POINT TO FPBF0) 
* 
      JSB UNPKS     GO UNPACK SOURCE LINE 
      JSB CHANG     DO CHANGE IN RAT4 
        DEF QX.1
        DEF LBUF0   INPUT LINE
^L2RE   DEF L2REB   OUTPUT LINE, USE LINE SPEC 2 BUFFEF AS TEMP !!! 
        DEF .150     MAX. OUTPUT LENGTH 
        DEF FREB0   MATCH PATTERN SPECIFICATION 
        DEF STBF0   UNFOLDED INPUT LINE  TO BE USED AS SUBITUTE SOURCE
        DEF RXSUB   SUBITUTE SPECIFICATION
QX.1  STA MTCH        SET MATCH FLAG
      SZA,RSS         IF ZERO THEN NO CHANGE
      JMP XRE,I         NO CHANGE SO CLEAN UP 
      LDA ^L2RE       GET BUFFER POINTER
      JSB PCK         PACK IT INTO TBUFF
*     JSB ./R$        REPLACE SOUCRE LINE 
      JMP XRE,I       RETURN
* 
* 
************************* 
* 
* 
**********************************************************
* 
ED%.F JSB FSCAN     GET ARGS
      LDA T#REC     START DEFAULT IS *+1
      ADA =D2 
$FB   LDB FRTNF     COPY FIND REUTRN FLAG 
      STB RTNFG     RETURN FLAG 
      JSB PSL1
      JMP L1ERR 
$FD   EQU * 
      LDA =D32767   DEFAULT FOR STOP LINE 
      LDB =D32767      AND NUMBER OF LINES IS PAST EOF
      JSB GETL2     GET LINE 2 NUMBER 
      JMP L2ERR     ERROR GO REPORT 
      CMA,INA       MAKE NUMBER OF LINE TO MOVE A LOOP COUNT
      STA FLOOP     AND SAVE
* 
.FY   EQU * 
      LDA NWTFG     COPY SAVED VERSION
      STA NWFLG        OF NO WINDOW FLAG TO REAL FLAG 
      CLA           CLEAR 
      STA FDCNT       LOOP COUNTER
      LDA SLNG      IF AT 
      SSA            END OF FILE
      JMP $FEX        GO DO FIND EXIT STUFF 
* 
$F1   JSB COMPS     GO DO COMPARE SEARCH
       DEF $F2
       DEF FBUF0    PASS FIND BUFFERS 
       DEF FLNG 
       DEF FREB0
       DEF FPBF0
       DEF FPLNG
$F2    EQU *
      JMP $FEX    FAILURE -MAY BE EOF OR LOOP COUNT 
      LDA ALLFG     SUCCESS TEST IF ALL SHOULD BE LISTED
      SSA,RSS 
      JMP DISPL    FIND ONLY FIRST - DISPLAY
      ISZ FDCNT     FIND ALL - BUMP COUNT(WILL NOT SKIP)
      LDB LSTFG     GET LIST FLAG 
      STB LSSAV     SAVE IT 
      LDB TRFLG     GET CURRENT STATE OF TRANFER FLAG 
      STB TRSAV     SAVE IT 
      STA TRFLG     SET TRANSFER FLAG 
      LDA QUFLG     GET QUIET FLAG
      CMA 
      STA LSTFG     AND SET COMPLEMENT IN LIST LIST 
      STA NLFLG     SET NUMBER LIST FLAG
      JSB TR        TRANSFER THIS SOURCE LINE 
      LDA LSSAV     RESTORE 
      STA LSTFG      LIST FAG 
      LDA TRSAV     RESTORE 
      STA TRFLG       TRANSFER FLAG 
      CLA           CLEAR 
      STA NLFLG       NUMBER LIST FLAG
      ISZ FLOOP     BUMP LIMIT COUNTER
      JMP $F1       LOOK FOR MORE 
      JMP $FEX      LIMIT REACHED - GO REPORT IT
* 
* 
ED%.B JSB FSCAN     GET ARGS
      CLA,INA       DEFAULT IS LINE ONE 
      JMP $FB       DO TRANSFER 
* 
******************************* 
*  DELETE LINES  - SPECIAL CASE FOR NO LINE SPECS 
* 
* 
ED%.D JSB FSCAN     SCAN FOR PARAMS 
      LDA QUFLG     COPY
      CMA            COMPLEMENTED 
      STA LSTFG          QUTITE FLAG TO LIST FLAG 
      JSB SETMS     SET DELETED FLAG CHARS
      CLA           IF
      STA TRFLG       NO START  LSEPC 
      LDA L1FLG           THEN
      SZA                    DELETE CURRENT LINE
      JMP $D1         SPEC GIVEN - SO GO USE IT 
      JSB UNDOD     SET UNDO INFO 
      LDA T#REC       SAVE CURRENT LINE AS START LINE 
      INA 
      STA L1LIN 
      JSB ASK         ASK FIRST 
      JSB TR          DELETE CURRENT (DONE FOR COMPATABILITY) 
      JMP $D2       AND SKIP THE POSITING 
* 
$D1   LDA T#REC     DEFUALT START LINE IS CURRENT LINE+1
      ADA =D2 
      JSB PSL1      MOVE TO THIS LINE SPEC 1
      JMP L1ERR 
      JSB ASK       ASK FIRST 
      JSB UNDOD     SET UNDO INFO 
$D2   CLA           CLEAR 
      STA TRFLG       TRANSFER FLAG 
      LDA QUFLG     GET QUITE FLAG
      CMA 
      STA LSTFG     SET LIST FLAG - (PSL1 MAY HAVE CLEARED IT)
      JMP $FD         NO  -  GO DO TRANSFER THEN MATCH
* 
LIMSG NOP 
      LDA ^LIMT     ASSUME LIMIT REACHED
      LDB SLNG      AT EOF ?  
      SSB       
      LDA ^EOF        YES - USE EOF INSTEAD OF LIMIT
      LDB ^FMSG 
      JSB .XFER     MOVE THE 3 WORDS
      JSB CNUMD     BUILD MATCH COUNTING PRINT FIELD
        DEF LMSG1 
        DEF FDCNT 
        DEF REXCT 
LMSG1   EQU * 
      LDA FDCNT     GET COUNT 
      LDB "NO 
      SZA,RSS       IF ZERO 
      STB RCTNO       SET 'NO' INSETAD OF ZERO
      LDA REFLG     TEST FOR REGULRER EXPRESSIONS 
      LDB SPSP
      SSA 
      LDB "RE"
      STB RCTRE 
      LDA FOLDF 
      LDB SPSP
      SSA 
      LDB "CF"
      STB RCTCF 
      JSB PRINT 
      DEF LIMSG,I   RETURN WHEN DONE
      DEC 15
      OCT 6412      CR/LF 
FMSG  BSS 3         FOR EOF/LIMIT 
REXCT BSS 2         FOR COUNT - UP TO 5 DIGITS
RCTNO BSS 1         FOR 'NO'
      ASC 5, matches
RCTCF BSS 1         FOR CASE FOLDING 'CF' 
      ASC 1,
RCTRE BSS 1         FOR REGULAR EXPRESSION 'RE' 
* 
* 
^FMSG DEF FMSG
"NO   ASC 1,No
"RE"  ASC 1,RE
"CF"  ASC 1,CF
SPSP  ASC 1,
* 
^EOF  DEF "EOF" 
"EOF" ASC 3,EOF 
^LIMT DEF "LIMT 
"LIMT ASC 3,Limit 
"._"  ASC 1,._
B40   OCT  40       A BLANK 
"A"   OCT 101 
"G"   OCT 107 
"N"   OCT 116 
"Q"   OCT 121 
"R"   OCT 122 
"S"   OCT 123 
"U"   OCT 125 
"V"   OCT 126 
"X"   OCT 130 
"Y"   OCT 131 
* 
LBYTE OCT 377 
* 
*********************************** 
* 
* 
$FEX  JSB LIMSG     GIVE LIMIT MESSAGE  
$FEX2 EQU * 
      CLA           SUPPRESS MUITLPLE COMMAND 
      STA PATCH 
* 
* 
* REPORT WINDOW <JDJ> 
*CPEOF LDA REFLG     TEST IF REGULAR EXPRESSION MODE
*      SSA
*      JMP .EOF1      YES - WINDOW NOT USED 
*      CLA           TEST IF
*      STA MCCNT       THIS IS
*      JSB MCH           A WINDOWED FIND
*      JMP EOFPR     NO CHAR SO NO. 
*      CPA ANCCH      WAS WINDOW CHAR GIVEN?
      LDA NWFLG     IS WINDOW IS IN EFFECT ?
      SSA,RSS 
      JSB RPRTW       YES - REPORT WINDOW 
      JMP .EOF1       GO TO EOR PROCESSING
* 
FLOOP BSS 1         NEGITIVE NUMBER OF LINES TO SEARCH BY COMPS 
FDCNT BSS 1         NUMBER OF MATCHES 
TRSAV BSS 1 
LSSAV BSS 1 
      SPC 1 
      SKP 
      HED FSAN SCAN FOR FIND TYPE ARGUMENTS 
* 
* 
FSCAN NOP 
      LDA REFLG     REGULAR EXPRESSION SET ?
      SSA 
      JMP FSC10       YES - GO DO REGULAR EXPRESSION
      JSB CSTRP     STRIP POSSIBLE COMMAN 
      JMP FSCN1       DEFAULTED PARAM - GO USE DEFAULT
      JSB FCOPY     COPY EBUFFER TO SCAN BUFFER 
        DEF FSCN0 
        DEF FBUF0     BUFFER
        DEF ZERO       ZERO OFFSET
        DEF FBUF0     DEFAULT IS CURRENT BUFFER 
        DEF FLNG
FSCN0   EQU * 
      STA FLNG      SAVE LENGTH 
FSCN1 LDA FLNG       RELOAD IN CASE OF DEFFAULT 
FSCN2 SSA           TEST FOR ERROR
      JMP ERR       GO REPOT THAT SOMETHING WRONG 
      CLA           CLEAR 
      STA NWTFG       NO WINDOW TEMP FLAG 
FSCN3 JSB CSTRP     STRIP COMMA TO GET TO OPTIONS 
      JMP FSCAN,I   DONE  RETURN
      JSB ECHL      GET OPTION
      JMP FSCAN,I    NONE SO RETURN 
      CCB           SET B FOR ALTER USE 
      CPA "A"       ALL MODE ?
      JMP FSCN4       YES - SET FLAG
      CPA "V"       REVERSE MODE
      JMP FSCN5       YES SET FLAG
      CPA "Q"       SET QUIET FOR DELETES ? 
      JMP FSCN6      YES - GO SET FLAG
      CPA DLMTR     IS IT THE DELIMTER ?
      JMP FSCN7       YES - MAY BE TO SUPPRESS ASKING 
      CPA "N"       IS NO WINDOW REQUESTED ?
      JMP FSCN9 
      JMP ERR       OPTION NOT KNOWN - ERROR
* 
FSCN4 STB ALLFG     SET ALL FLAG
      JMP FSCN3     TRY NEXT
* 
FSCN5 STB REVFG     SET REVERSE FLAG
      JMP FSCN3      TRY NEXT 
* 
FSCN6 STB QUFLG     SET QUIET FLAG
      JMP FSCN3       TRY NEXT
* 
FSCN7 JSB PBKE      PUT IT BACK 
      JSB SETOK     STRIP IT
      JSB ECH       GET NEXT CHAR 
      JMP FSCAN,I   NONE - SO OK
      JMP ERR       SOMETHING SO ERROR
* 
FSCN9 STB NWTFG     SET TEMP COMPY OF NO WINDOW FLAG
      JMP FSCN3 
* 
* 
* 
*     REGULAR EXPRESSION FIND 
FSC10 JSB CSTRP     REMOVE POSSIBLE COMMA 
      JMP FSC12       USE DEFAULT PARAMETERS
      JSB FCOPY 
        DEF FSC11 
        DEF FBUF0 
        DEF ZERO      NO OFFSET 
        DEF FBUF0    DEFAULT IS OLD BUFFER
        DEF FLNG
FSC11   EQU * 
      STA FLNG      SET LENGTH
FSC12 LDA FLNG      NEED TO RELAOD IN CASE OF DEFUATED
      SSA           TEST FOR ERROR
      JMP ERR       YES - REPORT
      JSB MKPAT     GO MAKE RE PATTERN
        DEF FSC13 
        DEF FBUF0   BUFFER
        DEF FLNG    LENGTH
        DEF FREB0   UNPACKED PATTERN
        DEF FPBF0   POSSIBLE MATCH
        DEF FPLNG      LENGTH 
FSC13   EQU * 
      JMP FSCN2     GO TEST FOR ERROR 
      SKP 
      HED EXCHANGE CODE 
*************************************************** 
* 
* EXCHANGE CODE - G,U,X,Y COMMANDS
* 
* 
* THESE BUFFERS ARE IN SEGMENT 2 - BE SURE IT IS LOADED IF YOU USE THEM 
* 
* 
* 
UFLG  DEC 0         FLAG IT IS AN X COMMAND 
* 
^ZERO DEF ZERO
*                               IN SEGMENT 2, AND OVERLAYS LINE SPEC 1 RE.
* 
^FLNG DEF FLNG+0
FPBUF DEF FPBF0+0 
^RMVF DEF ZRMVF+0   POINTER TO REMOVE ZERO LENGTH LINES FLAG
^REVF DEF REVFG+0   POINTER TO REVERSE FLAG 
^NWTF DEF NWTFG+0 
^SXFG DEF SXFLG+0   POINTER TO SINGLE EXCHANGE FLAG 
^QUFG DEF QUFLG+0   POINTER TO QUIET FLAG 
NWTFG BSS 1         TEMP COPY OF NO WINDOW FLAG 
SXFLG BSS 1         SINGLE EXCHANGE FLAG
* 
* 
* 
ED%.X LDA COMND     GET BACK COMMAND
      CPA "X"       FIND OUT WHICH ONE IT IS
      JMP %X
      CPA "G" 
      JMP %G
      CPA "Y" 
      JMP %Y
      JSB ECHL       MUST BE U  - GET NEXT CHAR 
      JMP ./U1      NONE SO USE DEFAULTS
      CPA "N"       IS THIS AN UNDO 
      JMP .UNDO       YES - GO DO IT
      JSB PBKE         NO - PUT CHAR BACK FOR LATER SCANNING
./U1  LDA ^ZERO     NO  DEFAULT FOR U PATTERN 
      JMP ./XU
* 
%G    EQU * 
*     JSB PRINT 
*     DEF NODE1 
*     DEC 3 
*     ASC 3,Use X 
* 
%Y    EQU * 
%X    EQU * 
      LDA ^FLNG 
./XU  STA XUDLN 
      CLA 
      STA NWTFG     CLEAR TEMPORY NO WINDOW FLAG
      STA SXFLG     CLEAR SINGLE EXCHANGE FLAG
      JSB CSTRP     REMOVE BLANKS 
        JMP .XUD        DEFAULTED PARAMTER RETURN 
      CCA           SET XFDLT 
      STA XDFLT       SO THAT WE WILL NOT SKIP SUB COPY 
      JSB FCOPY     COPY FIND TO XYBUFF 
        DEF .XU1
        DEF XYBUF,I   BUFFER
        DEF ZERO      OFFSET
        DEF FBUF0+0   DEFAULT IS FIND BUFFER
XUDLN   BSS 1         DEFAULT LENGTH
.XU1    EQU * 
      STA XLNG      SET LENGTH
      SSA           TST FOR ERROR 
      JMP .XU0
      SLA,INA,RSS   BUMP ONE TO YOFFSET,MAKE IT EVEN
      INA                 SO IT WILL BE A WORD BOUNDARY 
      STA YOFFS 
      JSB PBKE      PUT BACK THE DELIMTER 
.XUD0 EQU * 
      LDA REFLG     REGULAR EXPRESSION MODE ? 
      SZA,RSS 
      JMP .XUR3     NO SKIP REGULAR EXPERSSION PATTERN
      LDA COMND     GET COMMAND 
      CPA "U"       IS IT U ? 
      JMP .XUR3       YES - SKIP RE STUFF 
      JSB  MKPAT    MAKE THE PATTERN
        DEF .XUR1 
        DEF XYBUF,I PACKED SOURCE 
        DEF XLNG    LENGTH
        DEF FREB0+0  REUTRNED UNPACKED FIND PATTERN(BUF IN SEG 2) 
        DEF FPBF0+0  RETURNED PACKED POSSIBLE FIND PATTERN
        DEF FPLNG      AND LENGTH 
.XUR1   EQU * 
      SSA           IF NEGITVE THEN ERROR 
      JMP .XU0        YES - REPORT ERROR
.XUR3 ISZ XDFLT     WAS COMPLETE PATTERN DEFAULTED ?
      JMP .XUR4       YES - SKIP COPY OF SUBITUTE PATTERN 
      LDA ECCNT     SEE IF THERE IS ENOUGH ROOM 
      CMA,INA         XYBUF FOR 
      ADA ELNG          REST OF 
      ADA YOFFS          SUB
      CMA,INA             STRING
      ADA MAX 
      SSA           TEST IF NEGITIVE
      JMP .XU0        YES - FIELD IS TO LONG - GIVE ERROR 
      JSB FCOPY     COPY SUB BUFFER 
        DEF .XU2
        DEF XYBUF,I 
        DEF YOFFS   START AT Y OFFSET 
        DEF *       NO DEFAULT
        DEF ZERO     SO SEND IT ANY ZERO LENGTH BUFFER. 
.XU2    EQU * 
      STA YLNG      SET LENGTH
      SSA           TEST FOR ERROR
      JMP .XU0        YES  - REPORT ERROR 
.XUR4 LDA REFLG     IS THIS A REGULAR EXPRESSION ?
      SSA,RSS 
      JMP .XUR9     NO - SO SKIP RE STUFF 
      LDA COMND     GET BACK COMMAND
      CPA "U"       IS IT U ? 
      JMP .XUR9        YES - SKIP RE STUFF AGAIN
      JSB XRSUB     MAKE PATTERN
        DEF .XUR5 
        DEF XYBUF,I PATTERN 
        DEF YOFFS   OFFSET TO SUB LENGTH
        DEF YLNG    SUB SPEC LENGTH 
.XUR5 SSA           TEST FOR ERR
      JMP .XU0       YES- REPORT
.XUR9 EQU * 
* 
      JSB SETOK     SET OK FLAG IF PRESENT
.XU3  JSB CSTRP     STRIP BLANKS
        JMP .XU4       END OF BUFFER REACHED - GO EXCUTE
      JSB ECHL      GET OPTIONS 
        JMP .XU4       DONE - GO DO COMMAND 
      CLB           CLAER B REG AND USE IT AS FLAG
      CPA "Q"       Q OPTION GIVEN ?
      LDB ^QUFG       YES - GET PROINTER TO QUIET FLAG
      CPA "R"       R OPTION GIVEN ?
      LDB ^RMVF       GET POINTER TO REMOVE FLAG
      CPA "N"       NO WINDOW ? 
      LDB ^NWTF        GET POINTER TO NO WINDOW FLAG
      CPA "S"       SINGLE EXCHANGE ? 
      LDB ^SXFG        GET POINTER TO SINGLE EXCAHNGE FLAG
      SZB,RSS       DID B CHANGE ?
      JMP .XU0        NOT KNOWN - ERROR 
      CCA             YES - SET 
      STA B,I                FLAG.
      JMP .XU3      TRY NEXT
* 
* 
.XUD  LDA XLNG      TEST LENGTH 
      SSA 
      JMP .XU0      NEGITIVE SO ERROR 
      STA XDFLT     POSITIVE SO SET DEFULAT FLAG TO NOT -1
      JMP .XUD0     GO USE OLD BUFFERS
* 
XDFLT BSS 1         IF = -1 THEN USE OLD Y BUFFER 
* 
********
.XU4  EQU * 
* 
      LDA COMND     GET COMMAND 
      CPA "Y"       WAS IT A Y (REPLACE THEN FIND) ?
      JMP .Y1         YES - GO DO IT
*                               ELSE IT IS AN X OR U
      CCB 
      CPA "G"       IF G THEN SET QUIET  FLAG 
      STB QUFLG 
      LDA T#REC     DEFAULT FOR X,U CURRENT LINE
      INA 
      JSB PSL1      MOVE TO LINE SPEC 1 
       JMP L1ERR      ERROR - GO REPORT IT. 
      LDA L1LIN     DEFAULT IS FIRST LINE 
      LDB =D32767   AND LARGE COUNT AS THE MAX NUMBER 
      JSB GETL2    GO GET LINE 2 SPEC 
        JMP L2ERR     SOMETHING WRONG 
      STA TEMP     SAVE THE NUMBER TO MOVE
      JSB RPRTW 
      LDA TEMP      SKIP ASKING IF LESS THAN
      ADA =D-2        2 LINES 
      SSA,RSS 
      JSB ASK       THINGS SEEM OK - ASK IF NEEDED( MAY NOT RETURN) 
      CCB 
      STB EXFLG     SET DO EXCAHNGE FLAG
      LDA COMND    GET  COMMAND 
      CPA "U"       IF U THEN SET UNCOND FLAG 
      STB UNCON 
* 
      JSB SETXM     SETUP MATCH BUFFERS 
      JSB UNDOD     SET UP FOR UN OF D TYPE(SEG 2 MUST BE LOADED) 
      LDA TEMP     GET COUNT TO MOVE
      ADA =D-1      DON'T MOVE LAST ONE 
      SSA 
      JMP DISPL     IF IT WAS ZERO JUST DISPLAY CURRENT LINE
      CLB 
      STB FDCNT     CLEAR MATCH COUNTER 
      JSB TRN      AND MOVE THE LINES 
      LDA SLNG     AT EOF ? 
      SSA 
      JMP .XU9       YES - SKIP EXCHANGE ON LAST LINE 
      JSB ED%XU     DO EXCHANGE ON LAST LINE
      JSB I/PSB     DELETED LINE RETURN 
.XU9  LDA FDCNT     GET EXCHANGE COUNT
      SZA,RSS 
      JMP .XG1      IT'S ZERO - ALWAYS REPORT IT
      LDA COMND     TEST FOR G COMMAND
      CPA "G" 
      JMP .XG2        ITS G - SKIP REPORTING COUNT
.XG1  JSB LIMSG     REPORT MATCH COUNT
.XG2  JMP DISPL     DISPLAY CURRENT LINE AND GET NEXT COMMAND 
* 
.XU0  CCA           ERROR IN BUFFER 
      STA XLNG        MAKE LENGTH NEGITIVE
      JMP ERR 
**
*  SETXM SET THE PROPER PATTERN BUFFER INTO THE PATTER TO BE
*     SET BY COMPL
* 
SETXM NOP 
      LDA NWTFG     COPY TEMPORARY NO FILE FLAG 
      STA NWFLG       TO  NO WINDOW FLAG
      LDA REFLG     REGULAR EXPRESSIONS ? 
      SSA 
      JMP STXM1     YES - GO USE POSSIBLE MATCH BUFFER
      LDA XYBUF     NO  - USE XBUFF 
      LDB XLNG
      JMP STXM2 
* 
STXM1 LDA FPBUF     SET UP FOR REGULAR EXP. POSSIBLE MATCH BUFFER 
      LDB FPLNG       FOR COMPL.
STXM2 STA MBUFF 
      STB MLNG
      JMP SETXM,I   RETURN
* 
* 
***** 
* 
.Y1   JSB DFL1S     MOVE TO LINE SPEC 1 IF GIVEN
      JSB UNDOD     SAVE STATE IN CASE OF UNDO
      CCA           SET 
      STA EXFLG       EXCHANGE FLAG 
      JSB SETXM     SET UP MATCH SPECS
      JSB TR        MOVE PENDING LINE 
      SPC 1 
*  MOVE "X" PATTERN TO MATCH BUFFER 
* 
      CLA           CLEAR 
      STA EXFLG        EXCHANGE FLAG
      LDA XLNG      COPY LENGTH 
      STA FLNG
      INA           ROUND UP
      ARS             AND DIVIDE BY 2 
      STA TEMP
      LDA XYBUF     GET SOURCE ADDRESS
      LDB FBUFF       AND DEST. ADDRESS 
      JSB .MVW      MOVE THE WORDS
        DEF TEMP+0
        NOP 
      LDA =D32767 
      STA FLOOP     SET LOOP COUNT
      JMP .FY       AND GO DO FIND
      SPC 1 
* 
* 
* 
*.G1   JSB DFL1S     MOVE TO LINE SPEC 1, DEFAUTLS TO DOT 
*      LDA REFLG     REGULAR EXPRESSION ? 
*      SSA
*      JMP .G2       YES - GO DO IT 
*      JSB CXT       NO  - PERFORM EXCHANGE 
*      JMP DISPL      THEN DISPLAY LINE 
* 
*.G2   JSB XRE       GO DO REGULR EXPESSION EXCAHNGE
*      JMP DISPL       TEHN DISPLAY CURRENT LINE
**
**
*  ED%XU            EXCHANGE CODE 
* 
ED%XU NOP 
      LDA UNCON     TEST FOR UNCONDITIONAL EXCHANGE 
      SSA 
      JMP OPSB0      YES - SKIP REGULAR EXPRESSION STUFF
* 
* TEST FOR  R.E. PATTERN REPLACEMENT
* 
      LDA REFLG     RE PATTERN REPLACEMNET FLAG 
      SZA,RSS         SET ? 
      JMP OPSB0       NO -  DO SIMPLE TYPE EXCHANGE 
      JSB XRE         YES - GO DO IT
      JMP OPSB1     GO DO LIST
OPSB0 EQU * 
******* 
      JSB CXT       YES, PERFORM REPLACEMENT
OPSB1 LDA MTCH      DID  PATTERN
      SZA,RSS         MATCH?
      JMP OPSB3     NO - GO RETURN AND OUTPUT CURRENT SOURCE BUFFER 
      CLA           CLEAR LIST
      STA MTCH        MATCH FLAG. 
      LDB OCCNT     TEST FOR ZERO LENGTH SUBITUTE 
      SZB,RSS 
      JMP OPSB4     YES - GO CHECH IF WE SHOULD REMOVE IT 
OPSB2 JSB ./R$      REPLACE LINE WITH SUBITUTE
      CCA 
      STA NLFLG     SET NUMBERS LIST FLAG FOR LISTING 
      LDA QUFLG     TEST IF THIS IS QUIET MODE ?
      SZA,RSS         NO - LIST WHEN PATTERN MATCH OCCURS 
      JSB LSTSB     LIST NEW LINE 
      CLA           CLEAR NUMBERED
      STA NLFLG       LIST FLAG 
OPSB3 EQU * 
      ISZ ED%XU     BUMP RETURN SO WE WILL OUTPUT 
      JMP ED%XU,I 
* 
OPSB4 LDB ZRMVF     GET REMOVE ZERO LEN RECORD FLAG 
      SSB,RSS       IS IT SET ? 
      JMP OPSB2       NO  - GO OUTPUT ZERO LEN LINE 
      LDA QUFLG       TEST FOR LIST 
      SZA 
      JMP ED%XU,I      NO - RETURN NOW
      JSB SETMS     PUT IN DELETED FLAG 
      JSB LSTSB     LIST OLD LINE WITH DELETED FLAG 
      LDA SPSP      RESTORE 
      STA FILLC       FILL CHARS
      JMP ED%XU,I   RETURN AT DELETE POINT
* 
OPSBT BSS 1 
* 
* 
CXT   NOP           THIS ROUTINE DOES ALL THE 
      CLA            MATCHING IN THE SOURCE BUFFER
      STA OCCNT       AND REPLACEMENT IN THE
      STA SCCNT 
      LDB UNCON 
      SZB 
      JMP CXTUC 
      STA MTCH      CLEAR MTCH  FLAG. 
      LDB SBUFP     COMPUTE NEGITIVE BYTE 
      CLE,ELB         POINTER TO
      CMB,INB           START OF SOURCE LINE
      STB MB^SC     SAVE IT 
CXT1  JSB COMPL     SET FOR MATCH ON THE LINE 
       JMP CXT5       NONE - GO FINSISH UP
      ISZ FDCNT     BUMP MATCH COUNT
      NOP             IN CASE OF A SKIP 
      LDA MTCH      IS THIS THE FIRST MATCH ? 
      SZA,RSS 
      JSB XWBFR       YES- GO COPY CHARS BEFORE WINDOW
      CCA 
      STA MTCH      SET MATCH FLAG
      LDB CSTRT     GET WHERE MATCH STARTED.
      ADB MB^SC     COMPUTE NUMBER OF CHAR TO GET TO MATCH
      LDA SLNG      TEMPORARY 
      STB SLNG        SHORTENT SBUFF TO THIS
      STA TEMP
CXT2  JSB SCH       COPY
       JMP CXT3       CHARS 
      JSB OUTCR        BEFORE MATCH TO TBUFF
      JMP CXT2
* 
CXT3  LDA TEMP      RESTORE SBUFF LENGTH
      STA SLNG
      LDB CSTRT     TEST FOR NULL MATCH 
      CMB,INB 
      ADB CSTOP 
      SSB 
      JMP ERR       YES - PATTERN IS IN ERROR 
      INB           SKIP OVER 
      ADB SCCNT        MATCHED CHAR.
      STB SCCNT 
      CLA           CLEAR 
      STA YCCNT       SUBITUTE COUNT
RPC2  JSB YCH       MOVE
      JMP CXT4       REPLACEMENT CHARACTERS 
      JSB OUTCR       TO OUTPUT 
      JMP RPC2
CXT4  LDA SXFLG     TEST FOR SINGEL EXCHANGE
      SSA,RSS 
      JMP CXT1        NO - GO LOOK FOR MORE 
      SPC 1 
CXT5  LDA MTCH      TEST FOR A MATCH
      SZA,RSS 
      JMP CXT,I     NO MATCH SO RETURN
RPC4  JSB SCH       MOVE REMAINDER
      JMP CXT,I      OF SOURCE LINE 
      JSB OUTCR       TO OUTPUT 
      JMP RPC4
      SPC 1 
      SPC 1 
*     CODE FOR UNCONDITIONAL REPLACE. 
      SPC 1 
CXTUC CCA           SET FOR LIST
      STA MTCH
      ISZ FDCNT     BUMP COUNT
      LDA WIND1     SKIP OVER CHAR BEFORE WINDOW
      CMA,INA,SZA,RSS 
      JMP CXTU4 
      STA ASCII 
CXTU1 JSB SCH       MOVE SOURCE CHARACTERS
      LDA B40        PRECEEDING WINDOW
      JSB OUTCR       TO OUTPUT.
      ISZ ASCII 
      JMP CXTU1 
*CXTU2 JSB XCH       PASS OVER DUMMY SEARCH 
*      JMP CXTU3      PATTERN.
CXTU4 LDA XLNG
      CMA,INA,SZA,RSS 
      JMP CXTU5 
      STA ASCII 
CXTU2 EQU * 
      JSB SCH 
      NOP 
      ISZ ASCII 
      JMP CXTU2 
      SPC 1 
CXTU5 CLA           CLEAR 
      STA YCCNT      REPLACEMENT COUNT
CXTU3 JSB YCH       MOVE REPLACEMENT CHARACTERS 
      JMP RPC4       TO OUTPUT. 
      JSB OUTCR 
      JMP CXTU3 
      SPC 1 
MB^SC BSS 1 
*XCCNT NOP
YCCNT NOP 
* 
* "XCH" FETCHES NEXT CHARACTER FROM SEARCH PATTERN
*XCH   NOP
*      LDA XCCNT
*      CPA XLNG 
*      JMP XCH,I
*      ISZ XCCNT
*      ISZ XCH
*      CLE,ERA
*      ADA XYBUF
*      LDA A,I
*      SEZ,RSS
*      ALF,ALF
*      AND LBYTE
*      JMP XCH,I
* 
* "YCH" FETCHES NEXT CHARACTER FROM REPLACEMENT PATTERN 
YCH   NOP 
      JSB YCHR
        JMP YCH,I 
      ISZ YCH 
      CPA ESCCH     ESCAPED ? 
      JMP YCH1        YES - GET NEXT
      JMP YCH,I 
* 
YCH1  JSB YCHR      GET ESCAPED 
       LDA ESCCH       NONE SO USE THE ESCAPE CHAR
      JMP YCH,I     RETURN
* 
YCHR  NOP 
      LDA YCCNT 
      CPA YLNG
      JMP YCHR,I
      ISZ YCCNT 
      ISZ YCHR
      ADA YOFFS 
      CLE,ERA 
      ADA XYBUF 
      LDA A,I 
      SEZ,RSS 
      ALF,ALF 
      AND LBYTE 
      JMP YCHR,I
      HED XCASE     XOR CASE
* 
* 
XCASE NOP           CONDITIONAL XOR CASE
      IOR FDFLG     TEST FOLD FLAG ( LOW BYTE OF FLAG IS ZERO)
      RAL,CLE,SLA,ERA  IF SIGN BIT IS SET THEN DON'T FOLD 
      JMP XCASE,I     SET   SO JUST RETURN
      ADA =D-65     TEST IF 
      SSA             LESS THAN BIG A 
      JMP XCAS1        YES - NO CHANGE NEEDED 
      ADA =D-26     TEST
      SSA             IF UPPER CASE 
      JMP XCAS2         YES - FOLD TO LOWER 
      ADA =D-6      TEST IF 
      SSA             BETWEEN UPER AND LOWER
      JMP XCAS3         YES - NO CHANGE NEEDED
      ADA =D-26     TEST IF LOWER CASE
      SSA 
      JMP XCAS4       YES - FOLD TO UPPER 
      ADA =D123     ABOVE UPPER CASE RESTORE
      JMP XCASE,I   RETURN
* 
XCAS1 ADA =D65      RESTORE CHAR
      JMP XCASE,I   RETURN
* 
XCAS2 ADA =D123     FOLD TO UPPER AND RESTOR (65+26+32) 
      JMP XCASE,I 
* 
XCAS3 ADA =D97      RESTORE  (65+26+6)
      JMP XCASE,I     RETURN
* 
XCAS4 ADA =D91      FOLD TO LOWER   (65+26+6+26-32) 
      JMP XCASE,I   RETURN
********************************************************************* 
      SKP 
      HED COMPL     COMPARE CODE
* 
*     NAME: COMPL 
*     SUBROUTINE TO COMPARE PENDING LINE
*     CALLING SEQUENCE: 
*         JSB COMPL 
*         >NO MATCH RETURN HERE 
*         >MATCH RETURN HERE
* 
* 
*     THERE IS A  SPECIAL CHAR USED BY PATTERN BUILT BY MAKPT.
*     IT IS  MATCH  A LINE THAT ENDS AT THE START OF THE WINDOW.
* 
*    THE STARTING AND STOPPPING BYTE ADDRESS OF A MATCH IS LEFT IN
*    CSTRT AND CSTOP. 
* 
*     SOURCE CHAR COUNT IS ASSUME TO BE IN TEH CORRECT PSOITION 
*     WHEN COMPL IS CALLED. COMPL WILL BUMP THE COUNT TO THE
*     START OF TEH WINDOW IF NEDED. 
* 
*     COMPL FIND THE FIRST MATCH IN THE REMAINDER FOR A LINE. 
*     IT MAY BE CALLED MULTIPLE TIMES TO FIND ALL AMTCHES.
* 
COMPL NOP         TRY TO MATCH IN A LINE. 
      CLA 
      STA MCCNT     SET MATCH PATTERN TO FIRST CHAR 
      STA MCCN$     CLEAR RE-SCAN POINT 
      CCA           SET 
      STA C1STF       FIST MATCH FLAG 
      LDA NWFLG     SET IF WE SHOULD USE THE WINDOW 
      SSA 
      JMP CMPL0       FLAG SET SO SKIP WINDOW STUFF.
      LDB WIND1     GET A LOCAL COPY OF START OF WINDOW 
      LDA B         TEST IF SOURCE LINE 
      CMA,INA         IS LESS THAN
      ADA SLNG          START OF WINDOW 
      SSA 
      JMP COMPL,I       YES - SO CAN'T POSSIBLE MATCH 
      LDA B         TEST IF 
      CMA,INA         CURRENT POSITION IN 
      ADA SCCNT         SOURCE LINE IS LESS THAN
      SSA                 START OF WINDOW.
      STB SCCNT      YES - BUMP COUNT TO START OF WINDOW. 
      LDA WIND2     TEST IF LINES IS LONGER 
      ADA SLNG        THAN WINDOW 
      SSA 
      JMP CMPL0       NO - GO SET LIMIT TO END OF LINE. 
      LDB WIND2       YES - SET LIMIT AT END OF WINDOW
      CMB,INB,RSS   MAKE COUNT POSITIVE AND SKIP NEXT LOAD
CMPL0 LDB SLNG      COMPUTE SOURCE LINE LIMIT ADDRESS 
      INB           ROUND UP
      CLE,ERB         DIVED BY TWO  - 
      ADB SBUFP        COMPUTE WORD ADDRESS OF END
      STB CLIMT          AND SAVE.
      LDB SBUFP     GET SOURCE ADDRESS
      CLE,ELB       CONVERT TO BYTE ADDRESS 
      ADB SCCNT     BUMP TO CURRENT CHAR COUNT
      STB SDEF$     SET AS START OF RESCAN POINT
      JSB MCH       GET FIRST CHARACTER OF MATCH BUFFER 
      JMP CSEND       NONE - SUCCESSFUL MATCH 
      CPA ZLENG     LOOK FOR A ZERO LENGTH LINE ? 
      JMP CZERO       YES - GO TEST FOR ZERO LEN BUFFER 
      CPA ANCCH     ANCHORED MATCH ?
      JMP BOLMT      YES - GO SET UP
      JMP CSCN1     JUMP INTO SCAN SETUP
* 
* 
CSCAN JSB MCH 
        JMP CSEND     END OF PATTERN - MAY BE SUCCESSFUL MATCH
CSCN1 CPA INDEF     INDEFINITE CHARACTER? 
      JMP INDSU     YES - GO SET UP.
      CPA ESCCH     ESCAPE CHAR ? 
      JSB CMPLE       YES - GET NEXT
      CPA NUM3      SKIP SETUP IT THE FIRST ONE MATCHES - 
      JMP CSCN3       THIS IS DONE TO MAKE IT FASTER
      STA NUM3      NO - SAVE THE CHARACTER 
      ALF,ALF       SWAP IT TO HIGH BYTE
      STA NUM5      SAVE IT 
      ALF,ALF       GET BACK ORGINAL
      JSB XCASE     GET CHAR OF OPSITIE CASE ( BREG. SAVED) 
      STA NUM4
      ALF,ALF       SWAP IT TO HIGH BYTE
      STA NUM6        AND SAVE
CSCN3 LDA MCCNT     SAVE CURRENT POSTION OF PATTERN 
      STA MCCN$       FOR RESTARTS
CSCN2 CLE,SLB,ERB   CONVET BYTE ADDRES TO WORD ADDERESS 
      JMP CSODD       ODD  - LOW BYTE GO SET UP 
* 
* THIS IS THE LOOP WHICH SCANS TRYING TO MATCH THE FIRST CHAR AFTER 
* AND INDEF CHAR OR THE FIRST CHAR OF AN UN-ACHRORED PATTERN. 
* 
CLOOP CPB CLIMT     ARE WE AT END OF SOURCE LINE
      JMP COMPL,I     YES - RETURN NO SUCCESS.
      LDA B,I       GET NEXT SOURCE WORD
      AND CHBYT     LOOK AT HIGH BYTE FIRST 
      CPA NUM5
      JMP SHBYT       HIGH BYTE MATCHES - GO SAVE THIS ADDRESS
      CPA NUM6      TEST CASE XOR VERSION 
      JMP SHBYT       MATCHES - GO SAVE THIS ADDRESS
      XOR B,I       HIGH BYTE DID NOT MATCH, GET LOW BYTE 
CLOP2 EQU * 
      CPA NUM3
      JMP SLBYT       LOW BYTE MATCHED - GO SAVE THIS ADDRESS 
      CPA NUM4      TEST CAE XORED VERSION
      JMP SLBYT       MATCHES - GO SAVE THIS ADDRESS
      INB           BUMP ADDRESS - NEXT BYTE COMES FROM NEXT WORD 
      JMP CLOOP 
* 
* PUT DATA AND CONSTANTS CLOSE SO WE DON'T GET INDIRECTS
* 
CLIMT BSS 1 
NUM6  BSS 1 
NUM5  BSS 1 
NUM4  BSS 1 
NUM3  BSS 1 
NUM2  BSS 1 
NUM1  BSS 1 
SDEF$ BSS 1 
CHBYT OCT 177400    HIGH BYTE MASK
CLBYT OCT 377       LOW BYTE MASK 
* 
* 
**
CSODD LDA B,I       SETUP SCAN STARTING ON ODD BYTE 
      AND CLBYT     GET LOW BYTE CHAR 
      JMP CLOP2     JMP INTO LOOP 
* 
*  WE MATCHED IN THE LOW BYTE THE FIRST CHAR OF STRING  - SAVE THE ADDRESS
* 
SLBYT CCE 
      ELB           BUILD AN ODD BYTE ADDRESS 
      STB SDEF$     SAVE IT 
      CLE,ERB       GET BACK WORS ADDRESS 
      INB           BUMP WORD ADDRESS-NEXT BYTE COMES FROM NEXT WORD
* 
* GET HERE WHEN THERE IS A MATCH IN THE LOW BYTE -
*           TEST FOR MATCH IN HIGH BYTE 
* 
MHBYT JSB MCH       GET NEXT CHAR 
        JMP CENDH     END OF MATCH - LAST CHAR WAS IN LOW BYTE
      CPA INDEF     INDEFINATE CHAR ? 
      JMP INDHB       YES - GO SET IT UP STARTING AT HIGH BYTE. 
      CPA ESCCH     ESCAPED ? 
      JSB CMPLE       YES - GO GET NEXT CHAR
      CPB CLIMT     ARE WE AT THE SOURCE LIMIT ?
      JMP COMPL,I     YES - DID NOT MATCH ALL OF PATTERN SO FAILURE.
      CPA NUM1      TEST IF WE NEED TO SET UP 
      JMP MHBY1       THIS IS DO TO MAKE IT FASTER
      STA NUM1      SAVE CHAR TO MATCH TO 
      JSB XCASE     XOR CASE
      STA NUM2      AND SAVE IT 
MHBY1 LDA B,I       GET NEXT SOURCE WORD
      AND CHBYT     REMOVE LOW BYTE 
      ALF,ALF       PUT HIGH BYTE INTO LOW BYTE 
      CPA NUM1      DOES IT MATCH ? 
      JMP MLBYT       YES - GO TRY TO MATCH NEXT LOW BYTE 
      CPA NUM2      MATCH CASE XORED VERSION ?
      JMP MLBYT       YES - GO TRY NEXT LOW BYTE
* 
* STRING DOES NOT MATCH SO TEST FOR ANCHOR MATCH
* 
CRSRT LDA AFLAG     WAS THIS AN ANCHORED MATCH ?
      SSA 
      JMP COMPL,I     YES - NOT FOUND SO RETURN NOW 
* 
* HERE WE RE-START SCAN FOR FIRST CHAR MATCH
* 
      LDA MCCN$     RESET MATCH STRING TO 1ST CHAR AFTER INDEF
      STA MCCNT 
      ISZ SDEF$     BUMP BYTE RESTART ADDRESS.
      LDB SDEF$     PICK UP THIS ADDRESS
      JMP CSCN2       GO RESTART SCAN 
* 
* WE MATCHED IN THE HIGH BYTE THE FIRST CHAR OF A STRING - SAVE BYTE ADDRESS  
* 
SHBYT CLE,ELB       BUILD THE HIGH BYTE ADDRESS 
      STB SDEF$     SAVE IT 
      CLE,ERB       GET BACK WORD ADDRESS 
* 
* GET HERE WHEN THERE IS A MATCH IN THE HIGH BYTE - 
*           TEST FOR MATCH IN LOW BYTE
* 
MLBYT JSB MCH       GET NEXT CHAR 
        JMP CENDL     END OF MATCH - LAST CHAR WAS IN HIGH BYTE 
      CPA INDEF     INDEFINATE CHAR ? 
      JMP INDLB       YES - GO SET IT UP STARTING AT LOW BYTE.
      CPA ESCCH     ESCAPED ? 
      JSB CMPLE       YES - GO GET NEXT CHAR
      CPA NUM7      IF WE SAVE THIS CHAR BEFORE DON'T DO IT 
      JMP MLBY1        AGAING 
      STA NUM7      SAVE CHAR TO MATCH TO 
      JSB XCASE     XOR CASE
      STA NUM8      AND SAVE IT 
MLBY1 LDA B,I       GET NEXT SOURCE WORD
      INB           BUMP ADDRESS - NEXT BYTE COMES FROM NEXT WORD 
      AND CLBYT     REMOVE HIGH BYTE
      CPA NUM7      DOES IT MATCH ? 
      JMP MHBYT       YES - GO TRY TO MATCH NEXT LOW BYTE 
      CPA NUM8      MATCH CASE XORED VERSION ?
      JMP MHBYT       YES - GO TRY NEXT LOW BYTE
* 
* STRING DOES NOT MATCH SO GO TEST FOR RESTART/ANCHOR MATCH 
* 
      JMP CRSRT 
* 
NUM7  BSS 1 
NUM8  BSS 1 
* 
* HERE WE SET UP FOR INDEF MATCH
* 
INDHB CLE,RSS       START INDEF IN HIGH BYTE, BYTE ADDRESS EVEN 
INDLB CCE           START INDEF IN LOW  BYTE, BYTE ADDRESS ODD
      ELB           MAKE B INTO BYTE ADDRESS, E REG. HAS ODD/EVEN 
INDSU JSB STCST     GO SET START OF MATCH POINTER FOE EXCAHNGE
      STB SDEF$     SET CURRENT BYTE POSITION AS RESTART ADDTESS
      ISZ AFLAG     SET ANCHOR FLAG TO POSITIVE 
      JMP CSCAN     GO START SCAN 
      JMP CSCAN     GO START SCAN  < IN CASE OF SKIP >
* 
*  HERE WHEN MATCH PATTERN IS ALL USED. FIRST WE TEST IF LAST CHAR OF         
*   THE MATCH IS BEYOND THE LINE LENGTH.  THIS MAY OCCUR WHEN THER IS AN      
*   ODD NUMBER OF CHAR IN THE SOURCE AND THE LAST CHAR IN THE PATTER IS A     
*   BLANK.  NEXT TEST IF WINDOW IS OK. IF BOTH ARE OK THEN MATCH IS SUCCESS.
*   THE B REG. HAS SOURCE ADDRESS OF LAST MATCHED CHAR. 
*   THE 3 ENTRY POINTS DEPEND IF THE B REG. IS BYTE ADDRESS (CSEND) OR        
*   WORD ADDRESS AND LAST MATCH WAS AT LOW BYTE (CENDL) OR
*   WORD ADDRESS AND LAST MATCH WAS AT A HIGH BYTE (CENDH)
* 
* 
CENDH CLE,RSS       HIGH BYTE => BYTE ADDRESS IS EVEN 
CENDL CCE           LOW  BYTE => BYTE ADDRESS IS ODD
      ELB           MAKE B REG. A BYTE ADDRESS
CSEND JSB STCST     GO SET START OF MATCH POINTER IF NEEDED 
      ADB =D-1
      STB CSTOP     SET STOPPING ADDRESS
      LDA SBUFP     YES - CHECK IF WE WENT PAST IT
      CLE,ELA       MAKE IT BYTE ADDRESS
      CMA,INA       COMPUTE NUMBER OF CHAR MATCHED IN SOURCE LINE 
      ADA B 
      LDB A         WORK IN B REG. - TEST IF PAST SLNG
      INB           BUMP BY ONE 
      CMB,INB 
      ADB SLNG
      SSB 
      JMP COMPL,I     LAST CHAR IS PAST SLNG - NO MATCH 
      LDB NWFLG     IS WINDOW IN EFFECT?
      SSB 
      JMP CMPL9     NO - SO RETURN SUCCESS
      ADA WIND2     TEST IF WERE PAST THE WINDOW
      SSA 
      JMP CMPL9     NO - RETURN SUCCESS 
      JMP COMPL,I   YES - RETURN FAILURE
* 
* 
* 
CSTRT BSS 1         STARTING BYTE ADDRESS OF MATCH
CSTOP BSS 1         STOPPING BYTES OF MATCH 
C1STF BSS 1 
AFLAG BSS 1 
WINDF BSS 1         WINDOW FLAG 
**
**
**
      SPC 1 
CMPL9 ISZ COMPL   BUMP TO SUCESS RETURN 
      JMP COMPL,I AND RETURN
* 
* HERE WE START UP AN ANCHORED MATCH
* 
* 
BOLMT CCA           SET 
      STA AFLAG        ANCHORED FLAG
      JSB STCST     SET START OF MATCH TO CURRENT ADDRESS 
      ADB =D-1      BUMP ADDRESS BACK BY ONE
      CLE,SLB,ERB   CONVET TO WORD ADDRESS
      JMP SLBYT      ADDRESS WAS ODD - GO MATCH HIGH BYTE 
      JMP SHBYT      ADDRESS WAS EVEN - GO MATCH LOW BYTE 
* 
* 
CMPLE NOP           ESCAPE CHAR FOUND 
      JSB MCH       GET NEXT CHAR 
      LDA ESCCH     NONE SO IT THE CHAR ITSELF
      JMP CMPLE,I     RETURN
* 
STCST NOP           SET COMPL START OF MATCH BYTE ADDRESS 
      LDA SDEF$     GET WHERE LAST MATCH STARTED
      ISZ C1STF     TEST IF ADDRESS ALREADY HAS BEEN SET
      JMP STCST,I     YES - DO NOTHING
      STA CSTRT       NO  - SET BYTE ADDRESS
      JMP STCST,I       AND RETURN
* 
* 
CZERO JSB SCH       ANY MORE CHAR IN LINE ? 
        JMP CMPL9     NO  - GO BUMP RETURN ADDRESS
      JMP COMPL,I     YES - RETURN AT NO MATCH POINT
* 
* 
* 
ZLENG OCT 200       ZERO LENGTH CHAR.  NULL WITH BIT 7 SET
BOLCH OCT 201       BEGINNIG OF LINE   CNTL A WITH PARITY BIT 
* 
**************************************************************************
MCCN$ NOP           INPUT PATTERN LOCATION FOR INDEF SEARCH 
* 
      HED COMPS     SEARCH FOR MBUFF PATTERN
* 
* 
MBUFF BSS 1         MATCH BUFFER
MLNG  BSS 1         IT'S LENGTH 
MREBF BSS 1         RE MATCH BUFFER 
MPBUF BSS 1         POSSIBLE MATCH BUFFER 
MPLNG BSS 1           LENGTH
COMPS NOP           FIND MBUFF PATTERN
      JSB .ENTR 
        DEF MBUFF 
*   RETURN AT P+1 IF EOF OR MAX, P+2 IF FOUND 
      LDA MLNG,I    GET LENGTH  OF BUFFER WE ARE TO MATCH TO
      STA MLNG      AND SET AS LOCAL COPY 
      LDA REFLG     REGULAR EXPRESSION
      SSA 
      JMP CMRE1     YES GO SET POSSIBLE MATCH POINTERS
CMRE2 LDB SLNG      CHECK FOR EOF 
      SSB 
      JMP COMPS,I   YES , RETURN NOW
      JMP CMPS3      NO - JUMP INTO LOOP
* 
CMPS1 LDA REVFG     REVERSE MATCH ? 
      SSA 
      JMP CMPS5      YES - SO AN NOT FOUND IS A SUCCESS 
CMPS2 JSB TR        TRANSFER PENDING LINE 
      SSB           EOF ? 
      JMP COMPS,I     YES - RETURN
      ISZ FLOOP     TEST IF WE MOVED ENOUGH LINES 
      JMP CMPS3       NO - TRY NEXT LINE
      JMP COMPS,I     YES - RETURN AT P+1,NOT P+2 
CMPS3 JSB COMPL     COMPARE LINE
      JMP CMPS1       DOES NOT MATCH, TRY NEXT
      LDA REFLG     TEST IF WE SHOULD DO
      SSA,RSS        REGULAR EXPRESSION MATCHING
      JMP CMPS4       NO - RETURN SUCCESS 
      LDA MREBF       GET ADDRSS OFRE MATCH PATTERN 
      JSB RMTCH       GO DO IT
CMPSR JMP CMPS1     NO MATCH - TRY NEXT 
CMPS4 LDA REVFG     MATCH - TEST REVESE FLAG
      SSA 
      JMP CMPS2     SET SO A MATCH =>  FIND NEXT
CMPS5 ISZ COMPS     MATCH - BUMP RETURN 
      JMP COMPS,I   RETURN
* 
CMRE1 LDA MPBUF     COPY POSSILBE MATCH TO
      STA MBUFF       BUFFER TO BE USED BY COMPL
      LDA MPLNG,I   AND DO SAME WITH LENGTH 
      STA MLNG         ( NOTE CHANGE FROM REFERENCE TO VALUE) 
      JMP CMRE2     GO DO SEARCH
* 
* 
* "MCH" FETCHES NEXT FIND FIELD CHARACTER 
MCH   NOP 
      LDA MCCNT 
      CPA MLNG
      JMP MCH,I 
      ISZ MCCNT 
      ISZ MCH 
      CLE,ERA 
      ADA MBUFF 
      LDA A,I 
      SEZ,RSS 
      ALF,ALF 
      AND LBYTE 
      JMP MCH,I 
* 
MCCNT BSS 1         CURRENT COUNT 
*********************************************************************** 
* 
**************
* 
*     FORWARS LINES SPEC SEARCH SPEC  - SET FLAGS COPY BUFFERS
* 
* 
ED%FS LDA L1GIV     TEST IF THIS IS LIBE SPEC 1 OR 2
      CCB           -1 FOR LINE SPEC PATTERN  => FOWARD SEARCH
      SSA 
      JMP .FSH5     SPEC 2 - GO DO IT 
      STB L1PAT     SET LINE SPEC 1 PATTERN FLAG
      JSB SSPEC     SET UP THE BUFFERS
       DEF .FSH1
       DEF L1REB+0  THESE 
       DEF L1REP+0     BUFFERS ARE IN 
       DEF L1REL+0       SEGMENT 2
.FSH1  EQU *                                                                  
      JMP OFFSP     GO GET ANY OFFSET SPECS 
* 
* 
.FSH5 LDA L2FLG     HAS LINE SPEC 2 BEEN GIVEN ?
      SSA 
      JMP ERR         YES - SO ERROR
      STB L2PAT     SET LINE SPEC 2 PATTERN FLAG
      JSB SSPEC     SET UP THE BUFFERSER
        DEF .FSH6 
        DEF L2REB+0 THESE 
        DEF L2REP+0    BUFFER ARE IN
        DEF L2REL+0      SEGMENT 2
.FSH6   EQU * 
      JMP OFFSP     GO GET ANY OFFSET SPEC
* 
***************** 
*     BACKWARD LINE SEARCH SPEC - SETFLAG  COPY BUFFERS 
* 
* 
ED%BS LDA L1GIV     BACKWARDS SEARCH - GOOD ONLY IF 
      SSA             LINE SPEC 1 
      JMP ERR           HAS NOT BEEN GIVEN
      CLA,INA       ONE => BACKWARDS SEARCJ 
      STA L1PAT 
      JSB SSPEC     SET UP BUFFERS
        DEF .BSR1 
        DEF L1REB+0    THESE
        DEF L1REP+0       BUFFER ARE IN 
        DEF L1REL+0         SEGMENT 2 
.BSR1   EQU * 
      JMP OFFSP     GO GET NAY OFFSET SPECS 
* 
* 
*************************** 
* 
*  SSPEC  SEARCH SPEC  - COPY SEARCH SPEC IN TO THE SPECIFIED BUFFER
*     AND INTO FBUFF - BUILD REGULAR EXPRESSION PATTERN IF NEEDED 
* 
* 
REBUF BSS 1         REGULAR EXPERSSION BUFFER 
REPBF BSS 1         POSSIBLE MATCH BUFFER OR MATCH IF NOT RE
REPLN BSS 1         LENGTH
SSPEC NOP           SET UP SEARCH SPEC
      JSB .ENTR 
        DEF REBUF 
      JSB PBKE      PUT BACK THE DELIMITING CHAR
      JSB FCOPY     COPY FIELD TO TEH BUFFER
        DEF SSPC1 
        DEF REPBF,I 
        DEF ZERO    ZERO OFFSET 
        DEF FBUF0   DEFAULT IS IN FIND BUFFER 
        DEF FLNG
SSPC1   EQU * 
      STA REPLN,I   SET LENGTH
      SSA 
      JMP ERR       TEST FOR ERROR
      STA FLNG      COPY THIS BUFFER TO DEFAULT BUFFER
      INA 
      CLE,ERA       MAKE BYTE COUNT WORD COUNT
      STA TEMP
      LDA REPBF 
      LDB FBUFF 
      JSB .MVW
        DEF TEMP
        NOP 
      LDA REFLG     IS THIS REGULAR EXPERSSIONS 
      SSA,RSS 
      JMP SSPEC,I   NO RETURN NOW 
      JSB MKPAT     YES - BUILD RE PATTERNS 
       DEF SSPC2
       DEF FBUF0    SOURCE OF PATTERN 
       DEF FLNG      IT LENGTH
       DEF REBUF,I  WHERE TO PUT PATTERN
       DEF REPBF,I  WHERE TO PUT POSSIBLE PATTERN 
       DEF REPLN,I    AND ITS LENGTH
SSPC2   EQU * 
      SSA           TEST FO ERROR 
      JMP ERR         YES - GO REPORT 
      JMP SSPEC,I     NO RETURN 
* 
* 
****************************************************************
* 
*     SEARCH FOR LINE SPEC 1 - DOES BOTH FORWARD AND BACKWARD SEARCH
* 
*            L1LIN IS SET TO THE LINE NUMBER FOR THE MATCH
* 
*            FORWARD SEARCHS LEAVE FILE UNCHANGED 
*                RETURNS AT P+1 IF EOF, SET NFNDF FLAG
*                           P+2 IF MATCH FOUND
* 
*            BACKWARD SEARCH LEAVES FILE AT CURRENT LINE
*                RETURN AT P+1 IF NOT FOUND 
*                          P+2 IF MATCH 
* 
*            RETURN AT P+2 IF NO LINE 1 PATTERN GIVEN 
* 
* 
ED%S1 NOP           SEARCH FOR LINES SPEC 1 
      LDA L1PAT     TEST IF LINE 1 PATTERN GIVEN
      SZA,RSS 
      JMP LS1S0     NO SEARCH GIVEN SO RETURN NOW 
      SSA,RSS       FORWARD SEARCH ?
      JMP LS1S5       NO - GO DO BACKWARD SEARCH
      JSB LSFSH       YES - GO DO IT
        DEF LS1S1 
        DEF L1REB+0 FIND BUFFERS
        DEF L1REP+0  IN 
        DEF L1REL+0   SEGMENT 2 
LS1S1   EQU * 
      JMP LS1S4     NOT FOUND - USE NOT FOUND RETURN
      STA L1LIN       FOUND SET INTO LINE SPEC 1 LINE NUMBER
LS1S0 ISZ ED%S1     BUMP RETURN 
LS1S3 CCA           MAKE SURE WE HAVE TRANFER FLAG SET
      STA TRFLG 
      CLA           TURN OFF BREAK RETURNS
      STA BKRTN 
      JMP ED%S1,I 
* 
LS1S4 CCA           SET NOT FOUND FLAG
      STA NFNDF 
      JMP LS1S3     GO RETURN 
* 
******************* 
* 
LS1S5 LDA T#REC     BACKWARD SEARCH - GET CURRENT LINE NUMBER 
      INA 
      STA LSSTP     SET AS STOPING LINE 
      CCA 
      STA TRFLG     SET TRANSFER FLAG 
      JSB ./B1       ROLL TO TOP OF FILE
      JSB LSFSU     SET UP FOR FORWARD SCAN 
       DEF LS1S6
       DEF L1REB+0
       DEF L1REP+0
       DEF L1REL+0
LS1S6  EQU *
      JMP LS1S3     FILE EMPTY - RETURN NOW 
      CLA           SET LINE NUMBER TO LINE 0 
      STA L1LIN 
LS1S7 JSB LSFSN     SCAN FOR LINE 
        JMP LS1S9     NOT FOUND SO GO TEST IF L1LIN CHANGED 
      LDA LINES     GET WHERE MATCH IS FOUND
      STA L1LIN     SET AS START LINE 
      JSB TR        MOVE THIS LINE
      JMP LS1S7       (MAY SKIP IF BREAK OCCURES) 
      CLA           BREAK OCCURED 
      STA L1LIN       - SET L1LIN SO WE WILL REPOSITION 
LS1S9 CLA,INA       RESET SOURCE FILE TO LINE 1 
      JSB PSLN
      CCA           SET TRANSFER FLAG 
      STA TRFLG 
      CLA           CLEAR BREAK 
      STA BKRTN       RETURN FLAG 
      LDA L1LIN 
      SZA           DID A MATCH OCCUR WHICH CHANGED L1LIN ? 
      JMP LS1S0       YES - GO USE FOUND RETURN 
      LDA LSSTP     GET START LINE NUMBER 
      JSB ROLLN     MOVE TO THIS LINE 
      JMP LS1S4     RETURN AT P+1 WITH NFNDF FLAG SET 
* 
* 
*LSBSV BSS 1
* 
**********
* 
*  LINE SPEC 2 SEARCH - SEE COMMENT FOR ED%S1 
* 
* 
ED%S2 NOP           SEARCH FOR LINE SPEC 2 PATTERN
      LDA L2PAT 
      SZA,RSS 
      JMP LS2S0     NO SEARCH GIVEN SO RETURN NOW 
      JSB LSFSH     GO DO FOWADR SEARCH 
        DEF LS2S1 
        DEF L2REB+0 FIND BUFFERS
        DEF L2REP+0  IN 
        DEF L2REL+0   SEGMENT 2 
LS2S1   EQU * 
      JMP LS2S4     NOT FOUND - USE NOT FOUND RETURN
      STA L2LIN       FOUND SET INTO LINE SPEC 1 LINE NUMBER
LS2S0 ISZ ED%S2     BUMP RETURN 
LS2S3 CCA          MAKE SURE
      STA TRFLG      TRANSFER FLAG IS STILL SET 
      CLA           CLEAR 
      STA BKRTN       BREAK RETURN FLAG 
      JMP ED%S2,I 
* 
LS2S4 CCA           SET NOT FOUND FLAG
      STA NFNDF 
      JMP LS2S3     GO RETURN 
* 
*************************************************************** 
*  LSFSH            LINE SPEC FORWADR SEARCH
*                   1) DO SET UP WHICH SETS BUFFER ADDRESSES
*                   2) SKIP MATCH ON CURRENT LINE 
*                   3) SCAN FOR A MATCH 
*                   4) SET SAVE  FOUND LINE NUMBER AND RESTORE FILE 
*                      INCLUSING CHANGE TO CURRENT LINE IF NEEDED.
*              RETURNS AT P+1 IF EOF
*                         P+2 IF FOUND, A REG HAS SOURCE LINE NUMBER
* 
LSFSB BSS 1         RE BUFFER 
LSFSP BSS 1         RGULAR/POSSIBELMATCH BUFFER 
LSFSL BSS 1         IT'S LENGTH 
LSFSH NOP 
      JSB .ENTR 
        DEF LSFSB 
      LDA R$FLG     TEST IF CURRENT LINE HAS BEEN MODIFIED
      SZA,RSS 
      JMP LSFS0       NO - DISK COPY MATCHES IN CORE COPY 
      STA TRFLG       YES- MAKE COPY ON DISK - SET TRANSFER FLAG
      CLA 
      STA LSTFG     CLEAR LIST FLAG 
      LDA T#REC     GET 
      INA             CURRENT LINE    
      STA LSFSV         NUMBER AND SAVE IT. 
      JSB TR        MOVE CURRENT LINE TO DEST FILE. 
      LDA LSFSV     GET BACK WHERE WE WERE
      JSB ROLLN       AND ROLL THE FILE TO THE POSITION.
LSFS0 JSB LSFSU     DO SET UP 
        DEF LSFS1 
        DEF LSFSB,I 
        DEF LSFSP,I 
        DEF LSFSL,I 
LSFS1   EQU * 
        JMP LSFSH,I    AT EOF - RETURN NOW
      JSB TR        DON'T SEARCH CURRENT LINE 
      RSS             ALLOW SKIP IF BREAK 
      JMP LSFS2        TR BREAK - GO FINISH UP AS NOT FOUND 
      LDA =D32767   SET LSFSN STOP
      STA LSSTP        TO SOMETINE THAT WILL NOT OCCUR
      JSB LSFSN     SCAN FOR MATCH
        JMP LSFS2       NOT FOUND - RETURN
      LDA LSFSV     GET WHERE WE STARTED
      JSB PSLN      RESTORE THE SOURCE FILE POSITION
      LDA T#REC     COMPUTE THE LINE NUMBER 
      ADA LSCNT 
      ADA =D2 
      ISZ LSFSH     BUMP THE RETURN ADRESS
      JMP LSFSH,I     RETURN AT FOUND POINT 
* 
LSFS2 LDA LSFSV     RETURN
      JSB PSLN        SOURCE POSITION 
      JMP LSFSH,I 
* 
*********** 
*     SET UP FOR FOWARD SCAN
*      RETURN AT P+1 IF AT EOF
*                P+2 IF NOT 
* 
LSFBF BSS 1         FORWARD SEARCH RE BUFFER
LSFPB BSS 1         FORWARD SEARCH POSSIBLE MATCH BUFFER
LSFPL BSS 1            AND LENGTH 
LSFSU NOP           LINE SPEC FORWARD SEARCH SET UP 
      JSB .ENTR 
        DEF LSFBF 
      LDA SLNG
      SSA 
      JMP LSFSU,I   AT EOF SO RETURN NOW
      LDA LSFPB     SET MATCH BUFFER
      STA MBUFF        ADDRESS
      LDA LSFPL,I        AND LENGTH 
      STA MLNG             ( CHANGED FROM REFERENCE TO VALUE) 
      CLA           CLEAR 
      STA TRFLG       TRANSFER FLAG 
      STA LSTFG       LIST FLAG 
      CCA           SET 
      STA BKRTN       BREAK RETURN FLAG 
      LDA LINES     SAVE WHERE WE ARE 
      STA LSFSV 
      ISZ LSFSU     BUMP RETURN 
      JMP LSFSU,I    RETURN 
* 
********
*     SCAN FOR A LINE THAT MATCHES - RETURN AT P+1 IF EOF, BREAK, 
*                                          OR LINES = LSSTOP
*                                    RETURN AT P+2 IF FOUND 
*                   NUMBER OF LINES MOVED IS IN LSCNT 
* 
* 
LSFSN NOP           LINE SPEC FORWARD SEARCH SCAN 
      CLA 
      STA LSCNT     CLEAR COUNT 
      LDB SLNG      FIRST TEST FOR EOF
      JMP LSSN0     JMP INTO LOOP 
* 
LSSN1 ISZ LSCNT 
      JSB TR        TRANSFER LINE 
LSSN0 SSB           EOF ? 
      JMP LSSN9        RETURN 
      LDA LSSTP     TEST IF WE SHOULD STOP
      CMA,INA         IF STOP LINE
      ADA LINES          IS > THAN CURRENT LINE 
      SSA,RSS              THEN CONTINUE
      JMP LSSN9               NO - STOP SERACH NOW. 
      JSB COMPL     TEST IF LINE MATCHES
      JMP LSSN1      NO - TRY NEXT
      LDA REFLG     YES - TEST FOR REGULAR EXPRESSION MODE
      SSA,RSS 
      JMP LSSN2     NO - SKIP RE MATCH
      LDA LSFBF     YES - GET RE PATTERN
      JSB RMTCH     GO SEE IF IT MATCHES
      JMP LSSN1       NO - LOOP TO NEXT LINE
LSSN2 ISZ LSFSN 
LSSN9 EQU * 
      JMP LSFSN,I       RETURN
* 
* 
LSSTP BSS 1         LINE TO STOP AT 
LSCNT BSS 1         NUMBER OF LINES SCANED
* 
LSFSV BSS 1         TEMP
* 
      SKP 
      HED FCOPY COPY FIND FIELD 
* 
******************************************************************* 
* 
*   FCOPY - COPY DELIMTED FIND FIELD TO BUFFER
* 
*   CALLING SEQUENCE: 
* 
*     JSB FCOPY 
*       DEF RTN 
*       DEF BUFFER  BUFFER TO COPY TO (WORD ADDRESS)
*       DEF OFFSET  OFFSET TO START AT IN THIS BUFFER (BYTES) 
*       DEF DEFAULT DEFAULT BUFFER IF NULL FILED
*       DEF DLNG    LENGTH OF DEFAULT FIELD(IF<0 THEN ERROR)
*RTN     EQU *
*     STA LENGTH    A REG HAS LENGTH, OR -1 IF ERROR
* 
* 
*     ON RETURN A IS LENGTH OF FIELD ( -1 IF ERROR) 
* 
* 
****
* 
FCPYB BSS 1         BUFFER
FCPYO BSS 1         OFFSET
FCPYD BSS 1         DEFAULT BUFFER
FCPYL BSS 1         DEFAULT LENGTH
FCOPY NOP 
      JSB .ENTR 
        DEF FCPYB 
      JSB ECH       GET DELIMTER CHAR 
        JMP FCPY8     NONE SO USE DEFAULT 
      JSB PUNCT     TEST IF IT IS PUNCTION
        JMP FCPY0     NOT PUNCTION SO ERROR 
      STA FCPYX     SAVE DEMELITR 
      JSB ECH       GET NEXT CHAR 
        JMP FCPY7     NONE  GO CHECK FOR MORE IN RBUFF
      CPA FCPYX     IS THE FIELD EMPTY ?
        JMP FCPY8      YES - GO USE DEFAULT 
      JSB PBKE      NOT EMPTY - PUT THIS ONE BACK 
FCP10 LDB FCPYB     GET WORD ADDRESS OF START 
      CLE,ELB       MAKE IT A BYTE ADDRESS
      ADB FCPYO,I   BUMP THE OFFSET 
      STB FCPYB     AND SET THE BYTE ADDRESS
      CCA 
      STA FCPYO     RESET THE SAVED LAST CHAR 
      CLA           CLEAR THE 
      STA FCPYL       THE CHAR COUNTER
FCPY1 JSB ECH       GET A CHAR
        JMP FCP11   END OF COMMAND FOUND SO CHECK FOR MORE IN RBUFF 
      CPA FCPYX     DOES IT MATCH THE FIRST CHAR ?
      JMP FCPY4       YES - GO TEST FOR ESCAPE
      STA FCPYO     SAVE AS THE PREV  CHAR
FCPY2 ISZ FCPYL     BUMP THE CHAR COUNTER 
      LDB FCPYB     GET THE ADDRESS 
      JSB .SBT      PUT BYTE THERE
      STB FCPYB     SAVE THE UPDATED ADDRESS
      JMP FCPY1     LOOP
* 
FCPY3 CCB           RESET 
      STB FCPYO       PREV CHAR 
      JMP FCPY2     AND CONTINUE
* 
FCPY4 LDB FCPYO     GET PREV CHAR 
      CPB ESCCH     WAS IT THE ESCAPE ? 
      JMP FCPY3       YES - GO CLEAR PREV CHAR AND CONTINUE 
FCPY5 LDA FCPYL       NO  - GET LENGTH
      JMP FCOPY,I      AND RETURN 
* 
FCPY7 JSB FCPYA     GO CHECK FOR MORE IN RBUFF
       JMP FCPY8      EMPTY - GO DEFAULT
      JMP FCP10     SOME SO COPY BUFFER 
* 
FCPY8 LDA FCPYL,I   GET LENGTH
      STA FCPYL     MAKE LOCAL COPY 
      SSA           NEGITIVE ?
      JMP FCPY0       YES - ERROR 
      LDA FCPYD     GET DEFAULT ADDRESS 
      CLE,ELA       MAKE IT BYTE ADDRESS
      LDB FCPYB     GET DEST BUFFER ADDRES
      CLE,ELB       MAKE IT BYTE ADDRESS
      ADB FCPYO,I   BUMP BY OFFSET
      JSB .MBT      MOVE THE BYTES
        DEF FCPYL    (CHANGED REFERENCE TO VALUE AT FCPY8)
        NOP 
      JMP FCPY5     GO RETURN 
* 
FCP11 JSB FCPYA     GO CHECK FOR MORE IN RBUFF
        JMP FCPY5     EMPTY GO FINISH UP
      JMP FCPY1     GO GET NEXT CHAR ( WILL BE BAR) 
* 
FCPY0 CCA           ERROR - PUT -1 INTO A 
      JMP FCOPY,I   RETURN
*****************************                                 
*  HERE WHEN END OF COMMAND FOUND 
*   CHECK RBUFF FOR FOR MORE CHAR TO GIVE COMMAND SEPERATORS LOWER
*   PRESEDENCE THAN QUOTING 
FCPYA NOP 
      LDA PATCH     ARE THE MORE CHAR IN RBUFF ?
      SZA,RSS       
      JMP FCPYA,I     NO - END OF COMMAND  - RETURN AT P+1
      LDB EBUFF     YES - SO ADD COMMAND SEPERATER TO EBUFF 
      CLE,ELB 
      ADB ELNG
      ISZ ELNG
      LDA BAR 
      JSB .SBT
      JSB FLLER     COPY NEXT FIELD OF RBUFF TO EBUFF 
      ISZ FCPYA     BUMP TO MORE RETUNR 
      JMP FCPYA,I    RETURN 
*       
* 
* 
FCPYX BSS 1         DELIMTER CHAR SAVED HERE
* 
      END EDIT2 
                                                                                                                                                                                                        