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 *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