ASMB,R,Q,C * **************************************************************** HED RTE INTERACTIVE EDITOR * NAME: EDITR * SOURCE: 92070-18135 * RELOC: 92070-16135 * PGMR: HLC * * * **************************************************************** * * (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1979. 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. * * **************************************************************** * * NAM EDITR,3,50 92070-16135 REV.1941 800326 * EXT CREAT,READF,WRITF,CLOSE,PURGE,RWNDF EXT EXEC,LIMEM,LOGLU,REIO,CNUMD,.OPSY EXT NAMF,OPENF,LOCF,POST,PNAME,CRETS,GETST EXT KCVT,NAMR,.MVW,IFBRK,POSNT * * * * ENHANCEMENT WISH LIST: * 1) COMMAND TO TRANSFER TO COMMAND FILE (MACRO LIBRARY?). * AT COMPLETION, OR ON ERROR, INTERACTIVE EDITING WOULD RESUME. * ALLOW ECHO OF COMMAND FILE. * 2) BETTER HANDLING OF UPPER/LOWER CASE. SPECIAL CHARACTERS * TO CONTROL UPSHIFTING/DOWNSHIFTING. ABILITY TO FIND A PATTERN * OR SUBPATTERN WHERE CASE IS A "DON'T CARE". * 3) NEW COMMAND TO TERMINATE COMMAND REPITITIONS ON 'EOF'; IF NOT * SPECIFIED, 'EOF' WOULD NOT AFFECT REPITITION. * 4) ABILITY TO AUTOMATICALLY SET TABS ON PRINTING TERMINAL (2635). * 5) A BETTER WAY TO SPECIFY WHETHER THE LIST FILE IS TO * REMAIN OPEN AT THE END OF LIST COMMANDS. * 6) 'EP' COMMAND TO PURGE THE OLD COPY OF THE FILE AND CREATE A * NEW VERSION WITHOUT EXTENTS. * SKP * SUP * EDITL JSB GETST GET 'RU' PARAMETERS DEF *+4 DEF EBUF0 DEF M80 DEF ELNG * JSB PNAME MOVE NAME TO ABORT MESSAGE DEF *+2 DEF ABORT * JSB PNAME MOVE NAME TO 'INVALID PARAMETER' MESSAGE DEF *+2 DEF MS000 * JSB PNAME MOVE NAME TO 'INVALID COMMAND' MESSAGE DEF *+2 DEF MS001 * JSB PNAME MOVE NAME TO 'FILE NAME MISSING' MESSAGE DEF *+2 DEF MS002 * JSB PNAME MOVE NAME TO 'DELIMITER MISSING' MESSAGE DEF *+2 DEF MS004 * JSB PNAME MOVE NAME TO 'NO ROOM' MESSAGE DEF *+2 DEF MS005 * JSB PNAME MOVE NAME TO 'WRONG FILE TYPE' MESSAGE DEF *+2 DEF MS006 * JSB PNAME MOVE NAME TO 'WAITING FOR XXXXXX' MESSAGE DEF *+2 DEF WBUF * * LDB TBUFP INITIALIZE THE BUFFER POINTERS STB TBUFF LDB MBUFP STB MBUFF LDB PBUFP STB PBUFF LDB EBUFP STB EBUFF LDB XYBFP STB XYBUF * LDB M150 SET UP THE WINDOW STB WIND2 * LDB ";" INITIALIZE THE TABS STB TABCR LDB .7 TO COLUMNS 7 AND 21 STB TAB0 LDB .21 STB TAB0+1 * * LDB "/" SET THE DEFAULT SPECIAL CHARACTERS STB DLMTR LDB UNDEF STB TERM STB XXXXX STB NOT LDB "\" STB INDEF LDB %R STB REPLA LDB %B STB BREAK LDB %X STB XTEND LDB %C STB CANCL LDB %S STB INSRT LDB %T STB KLIP LDB %@ STB ZLNG * * LDB M3 DEFAULT TO BELL OFF STB / (THREE-CHAR PROMPT) LDB BELL STB /+2 * CCB STB RPCNT STB TTY ASSUME NO INTERACTION STB LIST ASSUME NO LIST DEVICE * LDB DSCR1 SET UP NAME POINTERS STB NAMO LDB DSCR2 STB NAMI * * JSB LIMEM LOCK AVAILABLE MEMORY AFTER THE PROGRAM DEF *+4 DEF ZERO GET AVAILABLE MEMORY DEF DCBI FIRST WORD DEF DCBSZ NO. OF WORDS * LDA DCBSZ ARS DIVIDE AVAILABLE MEMORY INTO TWO DCB'S ADA M16 STA DCBSZ LEAVE ROOM FOR DCB HEADER ADA M128 SSA JMP ER005 INSUFFICIENT MEMORY FOR DCB BUFFER LDA DCBI ADA .16 ADA DCBSZ STA DCBO START OF OUTPUT DCB * CLB CLEAR SOME EDITOR FLAGS STB SF1 STB SF2 STB LNAME STB PASS1 STB ECCNT STB TCCNT STB TAB0+2 STB INPUT STB WIND1 STB CCCNT STB LFLAG STB CLNG * JSB MVW ZERO THE DCB HEADERS DEF ZERO DEF DCBL LIST DCB .16 DEC 16 * JSB MVW DEF ZERO DEF DCBI,I INPUT DCB DEC 16 * JSB MVW DEF ZERO DEF DCBO,I OUTPUT DCB DEC 16 * JSB MVW DEF ZERO DEF DCBE COMMAND DCB DEC 16 * JSB MVW DEF ZERO DEF DCBSH SCRATCH DCB HEADER DEC 16 * JSB MVW DEF ZERO DEF DCBIH INPUT DCB HEADER DEC 16 * SKP * * OPEN SOURCE AND COMMAND FILES * JSB LOGLU GET TERMINAL LU NUMBER DEF *+2 DEF RUBSH STA LOG IOR EBIT ADD ECHO BIT STA ELOG IOR ZBIT ADD Z-BIT STA ZLOG LDA ELNG SZA JMP STRNG STRING PROVIDED, DO NOT PROMPT * STA TTY TERMINAL AVAILABLE STA LIST LIST DEVICE AVAILABLE LOGIN JSB TTYIP REQUEST INPUT DEF SORC? LDA EBUFF,I CPA ":." CLB,INB,RSS JMP STRNG CPB ELNG JMP ./AB COLON (ONLY INPUT) MEANS ABORT STRNG JSB SC.CR PARSE SOURCE INPUT NAME DEF INPUT NOP NULL FILE NAME CPA AA JMP ./AB ABORT IF NAME = "A" JSB SC.CR SCRATCH FILE SIZE DEF BUF10 NOP STA SSIZE+1 (DOUBLE PRECISION VARIABLE) JSB SC.CR SCRATCH CARTRIDGE REFERENCE DEF BUF10 NOP (SHOULD DEFAULT TO FASTEST/LARGEST DISC) STA SCART LDA TTY SZA,RSS JMP USLOG TERMINAL IS COMMAND DEVICE * JSB SC.CR PARSE COMMAND FILE NAME DEF ENAME JMP LOGON A=0, ASSUME TERMINAL CPA LOG JMP LOGON * JSB OPENW OPEN COMMAND FILE DEF DCBE DEF RUBSH DEF ENAME DEF ZERO OPTION DEF ESECR DEF ECART DEF .128 JSB FMPER PRINT ANY ERRORS DEF ENAME USLOG LDA INPUT SZA,RSS JMP NOSRC NO SOURCE FILE NAME * JSB OPENW OPEN SOURCE INPUT DEF DCBI,I DEF RUBSH DINPT DEF INPUT DEF ZERO STANDARD OPEN DEF ISECR DEF ICART DEF DCBSZ JSB FMPER PRINT ANY ERRORS DEF INPUT JSB FMP? JUMP IF ERROR DEF LOGIN TRY AGAIN * * JSB POST CLEAR DCB BUFFER DEF *+2 DEF DCBI,I JSB FMPER DEF INPUT JSB FMP? JUMP IF ERROR DEF LOGIN TRY AGAIN * * JSB LOCF FIND THE DISC LU DEF RTN12 DEF DCBI,I DEF RUBSH (ERROR ) DEF RUBSH (RECORD) DEF RUBSH (BLOCK ) DEF RUBSH (OFFSET) DEF ISIZE SIZE IN SECTORS DEF ICART LU RTN12 JSB FMPER PRINT ANY ERRORS DEF INPUT JSB FMP? JUMP IF ERROR DEF LOGIN TRY AGAIN LDA ICART CMA,INA STA ICART NEGATIVE LU * JSB MVW SAVE THE DCB HEADER TEMPORARILY DEF DCBI,I DEF DCBIH DEC 16 * JSB MVW THEN ZERO IT DEF ZERO DEF DCBI,I DEC 16 * * LDA ISIZE CONVERT SECTORS TO BLOCKS ARS * * CREATE SCRATCH FILES * NOSRC STA B COMPUTE DEFAULT SIZE FOR SCRATCH FILES ADA M24 SSA LDB .24 24 MINIMUM LDA SSIZE+1 SZA STA B OVERRIDE DEFAULT WITH OPERATOR INPUT STB SSIZE+1 * JSB CRETS CREATE SCRATCH FILE 1 DEF RTN1 DEF DCBO,I DEF RUBSH ERROR CODE DEF .1 FILE NUMBER DSCR1 DEF SF1 NAME DEF SSIZE DEF .4 TYPE DEF ZERO SECR DEF SCART DEF DCBSZ RTN1 JSB FMPER PRINT ANY ERRORS DEF SCRAX JSB FMP? JUMP IF ERROR DEF LOGIN TRY AGAIN * * JSB CRETS CREATE SCRATCH FILE 2 DEF RTN2 DEF DCBI,I DEF RUBSH DEF .2 FILE NUMBER DSCR2 DEF SF2 NAME DEF SSIZE DEF .4 TYPE DEF ZERO DEF SCART DEF DCBSZ RTN2 JSB FMPER PRINT ANY ERRORS DEF SCRAX JSB FMP? JUMP IF ERROR DEF LOGIN TRY AGAIN * LDA INPUT SZA,RSS JMP RWND NO SOURCE FILE, READY TO READ * * JSB POST CLEAR DCB BUFFER DEF *+2 DEF DCBI,I JSB FMPER DEF SF2 JSB FMP? JUMP IF ERROR DEF LOGIN TRY AGAIN * JSB MVW SAVE THE DCB HEADER DEF DCBI,I DEF DCBSH DEC 16 * JSB MVW AND BRING BACK THE INPUT HEADER DEF DCBIH DEF DCBI,I DEC 16 * JSB MVW THEN ZERO THE EXTRA COPY DEF ZERO DEF DCBIH DEC 16 * * LDA DINPT SWITCH THE NAME POINTERS STA NAMI STA PASS1 * SKP * * COMMAND INTERPRETER * * RWND JSB RWNDI REWIND INPUT FILE RWND2 JSB RWNDO REWIND OUTPUT FILE * READ1 JSB READ READ IN FIRST LINE * DISPL LDA TTY STA LIST LDA CBUF0 ALF,ALF AND LBYTE CPA "<" IF THE FIRST COMMAND IN THE SET WAS "<", RSS SKIP LISTING PENDING LINE JSB LSTSB LIST PENDING LINE * NODE1 CLA STA EXFLG CLEAR THE EXCHANGE FLAG LDA TTY STA LIST RESET LIST DEVICE * * 'X', 'Z', 'U', AND 'V' RETURN TO NODE2 UPON COMPLETION. * SO THE EXCHANGE PATTERN REMAINS ENABLED. * * NODE2 JSB TTYIP INPUT COMMAND DEF / JSB CAPS FETCH COMMAND CHARACTER LDA "/" NULL, DISPLAY NEXT LINE CPA STAR JMP NODE2 COMMENT, NO ACTION * STA COMND SAVE FOR LATER CPA "A" JMP ./A ABORT EDITOR CPA "_" JMP ./_ RESCAN THIS LINE OF COMMAND INPUT LDB SPACE RESET TAB FILL STB TBFIL TO SPACE CPA SPACE JMP APEND ADD A LINE CPA %G JMP ./CG MUTE BELL WITH PROMPT. CPA "P" JMP ./P DISPLAY PENDING LINE CPA ">" JMP ./> ALLOW LISTING CCB CPA "<" JMP ./< DISALLOW LISTING STB TRFLG ALLOW TRANSFER STB LCOMF ALLOW LISTING CPA "C" JMP ./P EDIT PENDING LINE & GOTO NEXT CPA "!" JMP ./! PRINT SOURCE FILENAME CPA "$" JMP ./$ LIST OR CHANGE SPECIAL CHARACTERS CPA "L" JMP ./L LIST SEVERAL LINES CLB STB LCOMF DON'T LIST CPA " JMP ./" DOUBLE EACH LINE CPA "&" JMP ./& APPEND NEXT LINE TO PENDING CPA "#" JMP ./# APPEND SEQUENCE NUMBERS CPA "O" JMP ./O COPY & EDIT PENDING LINE CPA "K" JMP ./K KILL TRAILING BLANKS CPA "M" JMP ./M MERGE FILE AFTER PENDING LINE CPA "?" JMP ./? ANSWER A QUESTION CPA "/" SLASH AND "+" MEAN THE SAME JMP NUMBR CPA PLUSS JMP NUMBR GO DOWN SEVERAL LINES CPA "E" JMP ./E END EDITOR CPA "N" JMP ./N DISPLAY PENDING LINE NUMBER CPA "T" JMP ./T CHANGE TABS CPA "U" JMP ./U UNCOND. REPLACE W/O LIST. CPA "V" JMP ./V THIS WITH LIST. CPA "W" JMP ./W SPECIFY A NEW WINDOW CPA "G" JMP ./Z EXCHANGE IN PENDING LINE CPA "X" JMP ./X EXCHANGE IN ALL LINES WITH LIST CPA "Y" JMP ./X EXCHANGE IN PENDING LINE AND SEARCH FOR NEXT MATCH CPA "Z" JMP ./Z EXCHANGE IN ALL LINES W O LIST CPA "^" JMP ./^ GO UP SEVERAL LINES STB TRFLG DON'T TRANSFER CPA MINUS JMP NUMBR DELETE SEVERAL LINES CPA "R" JMP ./R REPLACE PENDING LINE CPA "I" JMP ./I INSERT BEFORE CPA "D" JMP ./D DELETE UNTIL MATCH CCB STB TRFLG DO TRANSFER CPA "F" JMP ./F FIND MATCH CPA "B" COMPLETE TRANSFER AND START SEARCH JMP ./B FROM THE BEGINNING CPA "S" JMP ./S SEARCH AND MERGE CPA "@" JMP ./@ FIND MATCH STARTING WITH PENDING LINE CPA "H" JMP ./H PRINT HASH MARKS CPA TABCR JMP TABAP TAB, APPEND LINE ADA M58 CHECK FOR DIGIT SSA,RSS JMP ER001 ALPHA, ERROR ADA .10 SSA JMP ER001 * * THIS ROUTINE POSITIONS TO A GIVEN LINE NUMBER. * LINES IN THE SOURCE CHAIN ARE SKIPPED TO * INSURE THAT LINE NUMBERS MATCH RECORD NUMBERS * ON THE DISC. * CLA RESET COMMAND STA ECCNT CHARACTER POINTER JSB NUMIN COMPUTE LINE NUMBER CMA,INA,SZA,RSS COMPLEMENT AND IF ZERO CCA SET TO -1 STA COUNT AND SAVE STA TRFLG SET TRANSFER FLAG JSB NLSLU SET UP NEW LU IF GIVEN LDA LINES SZA,RSS IF NULL INPUT FILE JMP BCKUP BACK UP TO IT ADA COUNT SUBTRACT DESIRED LINE SSA,RSS JMP BCKUP STA COUNT JMP ./CC FIND IT *** AA ASC 1,A ":." ASC 1,: M24 DEC -24 M58 DEC -58 ZBIT OCT 10000 Z-BIT EBIT OCT 400 ECHO BIT LOG NOP TERMINAL LU ZLOG NOP TERMINAL LU + Z-BIT ELOG NOP TERMINAL LU + ECHO BIT * BUF10 BSS 10 PARSE BUFFER * ENAME BSS 3 COMMAND FILE NAME BSS 1 ESECR BSS 1 ECART BSS 1 BSS 4 * * PASS1 BSS 1 * .8 EQU * SORC? DEC 8 ASC 6,SOURCE FILE? OCT 6412 CARRIAGE RETURN, LINE FEED ASC 1,/_ PROMPT * * * * SCRAX ASC 3,-SCR- OCT 3 ASCII REP 6 NOP * LOGON CLA STA TTY STA LIST JMP USLOG NO COMMAND FILE, USE LOG DEVICE * * ER005 JSB REIO PRINT 'NO ROOM' MESSAGE AND ABORT DEF *+5 DEF .2 DEF LOG DEF MS005 DEF .8 JMP STOP ABORT EDIT * MS005 ASC 8,XXXXX 5-NO ROOM * "!" OCT 41 " OCT 42 "#" OCT 43 "$" OCT 44 "&" OCT 46 STAR OCT 52 ASTERISK "/" OCT 57 ";" OCT 73 TAB CHARACTER "=" OCT 75 "<" OCT 74 ">" OCT 76 "?" OCT 77 "@" OCT 100 "A" OCT 101 "B" OCT 102 "C" OCT 103 "D" OCT 104 "E" OCT 105 "F" OCT 106 "G" OCT 107 "H" OCT 110 "I" OCT 111 "K" OCT 113 "L" OCT 114 "M" OCT 115 "N" OCT 116 "O" OCT 117 "P" OCT 120 "R" OCT 122 "S" OCT 123 "T" OCT 124 "U" OCT 125 "V" OCT 126 "W" OCT 127 "X" OCT 130 "Y" OCT 131 "Z" OCT 132 "\" OCT 134 "^" OCT 136 "_" OCT 137 %B OCT 2 %C OCT 3 %G OCT 7 %R OCT 22 %S OCT 23 %T OCT 24 %X OCT 30 .1 DEC 1 .100 DEC 100 .1000 DEC 1000 .10K DEC 10000 .128 DEC 128 .13 DEC 13 .15 DEC 15 .2 EQU %B .21 DEC 21 .24 EQU %X .6 DEC 6 / OCT -4,6457,0 EDITOR PROMPT A EQU 0 B EQU 1 B133 OCT 133 B1640 OCT 16400 B77 EQU "?" BELL OCT 57407 UNDERSCORE,BELL CCCNT BSS 1 CURRENT POSITION IN COMMAND STRING CLNG BSS 1 LENGTH OF COMMAND STRING COMND BSS 1 CURRENT COMMAND COUNT BSS 1 RECORD COUNT FOR '+', '-', ETC. DCBI BSS 1 POINTER TO CURRENT INPUT DCB DCBO BSS 1 POINTER TO CURRENT OUTPUT DCB DCBSZ BSS 1 SIZE OF BOTH MAIN DCB'S ELNG BSS 1 LENGTH OF CURRENT COMMAND EBUFF BSS 1 POINTER TO CURRENT COMMAND EBUFP DEF EBUF0 ECCNT BSS 1 POSITION IN COMMAND BUFFER EXFLG BSS 1 EXCHANGE FLAG * * FNAME BSS 3 FILE NAME FOR MERGE, LIST FCODE BSS 1 FSECR BSS 1 FCART BSS 1 FTYPE BSS 1 FSIZE BSS 1 BSS 2 * * * * HLPNM ASC 3,&LHELP HELP FILE NAME FOR '?' COMMAND OCT 3 REP 6 NOP * * * * INPUT ASC 3,INPUT SOURCE FILE NAME ICODE BSS 1 ISECR BSS 1 ICART BSS 1 BSS 1 ISIZE BSS 1 BSS 2 * * LINES BSS 1 LINE COUNTER LIST BSS 1 TYPE OF LIST FILE LFLAG BSS 1 LISTING ALLOWED IF ZERO LCOMF BSS 1 -1 FOR LIST COMMANDS, 0 OTHERWISE M1 DEC -1 M10 DEC -10 M128 DEC -128 M150 DEC -150 M16 DEC -16 M2 DEC -2 M3 DEC -3 M80 DEC -80 MBUFF BSS 1 POINTER TO CURRENT MATCH BUFFER MBUFP DEF MBUF0 MINUS OCT 55 NAMI BSS 1 ADDRESS OF THE INPUT FILE NAME NAMO BSS 1 ADDRESS OF THE OUTPUT FILE NAME * PBUFF BSS 1 POINTER TO THE PENDING LINE BUFFER PBUFP DEF PBUF0 PLNG BSS 1 LENGTH OF PENDING LINE PCCNT BSS 1 CURRENT POSITION IN PENDING LINE PLUSS OCT 53 RPCNT BSS 1 REPEAT COUNT FOR COMMAND INPUT RUBSH BSS 1 ANYTHING I DON'T WANT GOES HERE * SF1 ASC 3,SF1 SCRATCH FILE NAME OCT 3 REP 6 NOP * SF2 ASC 3,SF2 SCRATCH FILE NAME OCT 3 REP 6 NOP * SCART NOP SCRATCH FILE CARTRIDGE REFERENCE * SLNG NOP NUMBER OF RECORDS ON THE STACK SPACE OCT 40 SSIZE DEC 0,0,0,0 DOUBLE INTEGER SCRATCH FILE SIZE T#WDS OCT 0,0 CURRENT # OF WORDS IN DEST. FILE T#REC BSS 1 CURRENT # OF REC IN DEST FILE * TAB0 BSS 10 ARRAY OF TAB STOPS DEC 0 ARRAY TERMINATOR TABUF DEF TAB0 POINTER TO THE TAB SETTINGS BUFFER TBFIL BSS 1 FILL CHARACTER FOR WHEN TAB IS USED TBPNT BSS 1 INDEX TO WHICH TAB SETTING * TBUFF BSS 1 POINTER TO TEMPORARY BUFFER TTY BSS 1 INTERACTIVE COMMAND INPUT DEVICE IF 0 TCCNT BSS 1 NUMBER OF CHARACTERS ACTUALLY IN TBUFF TBUFP DEF TBUF0 TRFLG BSS 1 TRANSFER ENABLED IF -1 TRUNC BSS 1 UNDEF ASC 1,?? WIND1 BSS 1 STARTING COLUMN OF THE WINDOW::DEFAULT=0 WIND2 BSS 1 END COLUMN OF THE WINDOW::DEFAULT=150 * * * XYBUF BSS 1 POINTER TO EXCHANGE BUFFER XYBFP DEF XYBF0 %@ EQU * ZERO-LENGTH-LINE CONSTANT ZERO REP 16 OCT 0 * SKP * * DOUBLE PENDING LINE * * ./" JSB NUMIN GET COUNT CMA,INA,SZA,RSS CCA DEFAULT TO PENDING LINE ONLY STA COUNT LDA PLNG SSA JMP DISPL END OF FILE - NO ACTION ./"1 CLA STA TCCNT RESET OUTPUT BUFFER COUNT JSB PCH GET PENDING LINE CHARACTER JMP *+3 END OF LINE JSB OUTCR OUTPUT TO TBUF JMP *-3 ALL OF LINE * CLA STA PCCNT RESET PENDING LINE CHAR COUNT JSB PCH JMP *+3 END OF PENDING LINE JSB OUTCR OUTPUT TO TBUF AGAIN JMP *-3 ALL OF LINE * JSB ./R$ REPLACE PENDING LINE WITH TBUF ISZ COUNT RSS JMP DISPL DONE, DISPLAY PENDING LINE JSB TR COPY TO OUTPUT FILE JMP ./"1 NEXT LINE SKP * * '&' COMMAND -- APPEND NEXT LINE TO PENDING LINE * ./& LDA PLNG SSA JMP DISPL END OF FILE, NO ACTION JSB PCH MOVE PENDING LINE TO TBUFF JMP *+3 JSB OUTCR JMP *-3 * JSB READ READ NEXT LINE SSA JMP ./&1 END OF FILE, RESTORE PREVIOUS LINE JSB PCH ADD TO PREVIOUS PENDING LINE JMP *+3 JSB OUTCR JMP *-3 * ./&1 JSB ./R$ MOVE TBUFF TO PENDING LINE JMP DISPL DISPLAY RESULT SKP * * 'L' COMMAND -- LIST N LINES * ./L CLA STA LIST * * '-', '/', AND '+' COMMANDS * NUMBR JSB NUMIN READ NUMERIC PARAMETER CMA,INA,SZA,RSS COMPLEMENT NUMBER CCA IF NUMBER IS ZERO SET STA COUNT TO -1 JSB NLSLU SET UP NEW LU IF GIVEN ./CC JSB TR FNUM2 ISZ COUNT FOUND LINE NUMBER? JMP ./CC NO, FETCH NEXT LINE JMP DISPL YES, DISPLAY IT *** * * 'F' COMMAND * ./F JSB TAB EXPAND TABS SERCH JSB M.T MOVE PATTERN TO MATCH BUFFER NEXT JSB TR WRITE PENDING LINE & READ NEXT COMP@ JSB MACH? COMPARE PENDING LINE TO MATCH BUFFER JMP NEXT PATTERN NOT FOUND - CONTINUE JMP DISPL FOUND - DISPLAY IT * * * '@' COMMAND * ./@ JSB TAB EXPAND ANY TABS JSB M.T MOVE PATTERN TO MATCH BUFFER LDA PLNG SSA JMP DISPL END OF FILE, NO MATCH JMP COMP@ COMPARE STARTING WITH PENDING LINE * * * 'D' COMMAND -- DELETE TO PATTERN * ./D JSB TAB EXPAND TABS JSB M.T MOVE PATTERN TO MATCH BUFFER JSB TTYIP ASK FOR LIMIT DEF MAXDL JSB NUMIN CMA,INA,SZA,RSS JMP DISPL ZERO, NO LINES LOST STA COUNT JSB NLSLU SET UP NEW LIST FILE ./D1 JSB TR TRANSFER RECORD JSB MACH? CHECK FOR MATCH RSS JMP DISPL FOUND IT ISZ COUNT JMP ./D1 CONTINUE JMP DISPL LINE LIMIT EXCEDED * * MAXDL DEC 10 ASC 10,MAX. NO. OF LINES? _ FOR DELETE * * * * * * '<' AND '>' COMMANDS * ./> JSB NLSLU OPEN NEW LIST FILE JSB NLSLU (ALLOW FOR COMMA BEFORE FILE NAME) CLB AND ALLOW LISTING ./< STB LFLAG LIST FLAG JMP NODE1 FETCH NEXT COMMAND * * * * * REPEAT BLOCK OF COMMANDS * * * ./_ JSB NUMIN GET REPEAT COUNT CMA,INA,SZA,RSS CCA DEFAULT TO ONE LDB TRUNC STB CLNG STB CCCNT RESET COMMAND BUFFER POINTERS SZB,RSS ADA M1 NULL COMMAND HAS NOT YET EXECUTED STA RPCNT JMP NODE1 FETCH FIRST COMMAND IN LINE * SKP * * * BACK UP 'N' LINES * LINES ARE RE-NUMBERED IF ADDITIONS OR DELETIONS HAVE BEEN MADE * * ./^ JSB NUMIN BACK UP 'N' LINES CMA,INA,SZA,RSS CCA DEFAULT TO ONE LINE ADA T#REC SSA,RSS CMA,SZA,RSS COMPUTE LINE NUMBER IN OUTPUT FILE CCA STA COUNT JSB NLSLU CHECK FOR LIST DEVICE * * BCKUP LDA EXFLG SZA,RSS JMP NOEXC EXCHANGE NOT ENABLED * FNUM3 JSB ./B1 ROLL OVER FILE JSB READE READ FIRST LINE JMP FNUM2 * NOEXC STA LCOMF INHIBIT LISTING LDB T#REC ADB COUNT LINE NUMBER IN OUTPUT FILE CMB,SZB,RSS JMP DISPL ALREADY AT THE LINE STB BKUPC BACK-UP LINE COUNT * JSB POSTI FREE UP THE INPUT BUFFER * PUSHM JSB PUSH PUSH A LINE ONTO THE STACK JMP FNUM3 STACK OVERFLOW * JSB GET GET A LINE FROM THE OUTPUT FILE JMP RWND2 START OF FILE, DONE * JSB FMP? CHECK FOR FMP ERRORS DEF WE JSB BRK? CHECK BREAK FLAG DEF WE JMP OUT ISZ BKUPC JMP PUSHM * WE JSB WEOF WRITE AN END OF FILE JMP DISPL DISPLAY THE NEW PENDING LINE * BKUPC NOP * SKP * * APPEND SEQUENCE NUMBERS *** ./# JSB ECH SKIP OVER NOP ALPHA COMMENT. JSB ECH NOP JSB ECH NOP JSB NUMIN FETCH START NUMBER STA BASE AND SAVE AS BASE JSB NUMIN FETCH 2ND NUMBER SZA,RSS IF ZERO SET LDA .10 TO 10 AND STA INCR SAVE AS INCREMENT JSB NUMIN FETCH STARTING COLUMN CMA,INA,SZA,RSS LDA M73 DEFAULT TO COLUMN 73 STA COLMN JSB ./B1 GO TO BEGINNING OF FILE JSB READE READ A LINE *** ./#1 CLA RESET CHARACTER OUTPUT STA TCCNT COUNTER LDA COLMN MOVE INA,SZA,RSS JMP ./#3 START IN COLUMN ONE STA COUNT FIRST PART OF SOURCE ./#2 JSB PCH CHARACTERS LDA SPACE OF SOURCE JSB OUTCR TO OUTPUT ISZ COUNT BUFFER JMP ./#2 * ./#3 CLA,INA SET UP COMMAND STA ECCNT BUFFER COUNTER LDA M3 SET UP LOOP STA COUNT COUNTER FOR 3 CHARACTERS ./#4 JSB ECH FETCH NEXT ALPHA COMMENT LDA SPACE LOAD BLANKS IF NO COMMENT JSB OUTCR OUTPUT CHARACTER ISZ COUNT THIRD CHARACTER? JMP ./#4 NO, FETCH NEXT CHARACTER *** LDA BASE OUTPUT LINE NUMBER CLB JSB DEC IN ASCII LDA BASE UPDATE ADA INCR LINE STA BASE NUMBER JSB ./R$ SWAP TBUFF AND PBUFF JSB TR WRITE PENDING LINE AND READ NEXT JMP ./#1 CONTINUE *** BASE NOP INCR NOP COLMN NOP M73 DEC -73 SKP * * SET UP WINDOW FOR SEARCH AND EXCHANGE COMMANDS * ./W JSB CHKN CHECK PARAMETERS JSB NUMIN FETCH SZA START OF ADA M1 WINDOW STA CHKN POINTER JSB NUMIN FETCH CMA,INA,SZA,RSS END OF LDA M150 WINDOW STA B POINTER ADA CHKN TEST THAT START IS BEFORE END SSA,RSS JMP ER000 LDA CHKN STA WIND1 STORE NEW VALUES STB WIND2 JMP NODE1 GET NEXT COMMAND * SKP * * DELETE TRAILING BLANKS FROM THE FILE * ./K JSB ./B1 ROLL-OVER FILE JSB READE READ FIRST LINE ./K1 LDA PLNG INA ROUND UP CLE,ERA CONVERT TO WORD COUNT ./K2 ADA M1 BACK UP ONE WORD SZA,RSS JMP ./K3 DO NOT DELETE LAST WORD LDB PBUFF ADB A LDB B,I CPB SPSP CHECK FOR 2 BLANKS JMP ./K2 YES, DECREMENT LINE LENGTH ./K3 INA ALR CONVERT TO CHARACTER COUNT STA PLNG STORE NEW RECORD LENGTH JSB TR MOVE NEW RECORD TO DEST. FILE JMP ./K1 AND FIX IT * SKP * * SET UP TAB CHARACTER AND TAB STOPS * ./T JSB ECH STEP PAST TAB CHAR. JMP ./T1 NONE, SO DISABLE TAB JSB CHKN OTHERWISE CHECK PARAMETERS JSB ECH GET TAB CHARACTER ./T1 LDA UNDEF DISABLE TABS STA TABCR STORE TAB CHARACTER LDA TABUF RESET TAB ADDRESS STA TBPNT POINTER LDA M10 10 TAB STOPS MAX. STA TR STA TABSV TERMINAL TABS NEED TO BE SET LDA ECCNT IF ONLY TAB CHARACTER CPA ELNG GIVEN, THEN RETURN JMP ./$1 WITH TABS UNCHANGED NXTNM JSB NUMIN GET NEXT NUMBER STA TBPNT,I STORE TAB NUMBER ISZ TBPNT BUMP POINTER ISZ TR LAST TAB? JMP NXTNM NO, CONTINUE JMP ./$1 GO PRINT SPECIAL CHARACTERS * SKP * * THIS ROUTINE SETS UP THE X-Y BUFFER. THE FIRST * HALF OF THE BUFFER IS MATCHED AGAINST THE PENDING * LINE. IF THE MATCH SUCCEEDS, THE SECOND HALF * OF THE X-Y BUFFER REPLACES THOSE CHARACTERS. * ./U CLA ./V CCB,RSS ./Z CLA IF "Z" RESET LIST FLAG ./X STA XLIST IF "X" OR "Y" SET FLAG STB UNCON CLB,INB STB EXFLG SET EXCHANGE FLAG CPB ELNG JMP XSET1 NULL PATTERN, USE PREVIOUS PATTERN LDA EBUFF,I AND LBYTE CPA DLMTR JMP FINDP FIRST CHAR IS DLMTR, USE 'F' PATTERN XSET4 ALF,ALF IOR DLMTR ALF,ALF STA EBUFF,I INSERT WINDOW CHARACTER XSET2 JSB ECH FETCH NEXT PATTERN CHARACTER JMP ER004 NO DELIMITER CPA DLMTR IF NULL PATTERN CHARACTER CCA,RSS JMP XSET2 ADA ECCNT STA XLNG LENGTH OF MATCH FIELD INA STA YOFFS OFFSET OF REPLACEMENT FIELD WITHIN BUFFER CMA,INA ADA ELNG STA YLNG REPLACEMENT PATTERN LENGTH LDA EBUFF LDB XYBUF STB EBUFF STA XYBUF XSET1 LDB COMND LOAD COMMAND CHARACTER CPB "G" PENDING LINE EXCHANGE? JMP ./G YES - GO DO IT CPB "Y" IF "Y" COMMAND CLA,RSS PERFORM SEARCH JMP NODE2 ELSE, FETCH NEXT COMMAND *** * COPY PATTERN TO MBUFF AND SEARCH STA MX.CN RESET EXCHANGE AND STA TCCNT OUTCR CHARACTER COUNTERS LDA XLNG STA MX.LN LDA XYBUF STA MX.BF XSET5 JSB MX.CH EXCHANGE CHARACTER JMP SERCH END OF PATTERN JSB OUTCR JMP XSET5 * LBYTE OCT 377 ./G JSB CXT PERFORM EXCHANGE IN PENDING LINE ONLY JMP DISPL THEN DISPLAY LINE * UNCON NOP XLIST NOP XLNG NOP YLNG NOP YOFFS NOP * * FINDP LDB UNCON SZB JMP XSET4 UNCONDITIONAL EXCHANGE STB MX.CN USE PREVIOUS 'FIND' PATTERN LDA MBUFF STA MX.BF LDA MLNG STA MX.LN STA YOFFS ISZ YOFFS STA XLNG OLD PATTERN LENGTH LDA ELNG ADA M2 STA YLNG NEW PATTERN LENGTH * LP1 JSB MX.CH FETCH 'FIND' CHAR JMP LP2 JSB OUTCR JMP LP1 * LP2 JSB ECH FETCH NEW PATTERN CHAR JMP XSET3 END OF INPUT JSB OUTCR JMP LP2 * XSET3 LDA TBUFF SWAP TBUFF AND EXCHANGE BUFFER LDB XYBUF STB TBUFF STA XYBUF JMP XSET1 * SKP * * TAB CHARACTER COMMAND -- APPEND LINE * TABAP CLA STA ECCNT * * INSERT LINE OF TEXT AFTER PENDING LINE * APEND LDA PLNG IF NOT AT SSA,RSS EOF THEN JSB OUTPT OUTPUT CURRENT LINE * * * REPLACE PENDING LINE WITH LINE IN OUTPUT BUFFER * ./R JSB TAB EXPAND TABS JSB ./R$ PERFORM REPLACEMENT JMP NODE1 GET NEXT COMMAND * * INSERT LINE OF TEXT BEFORE PENDING LINE * ./I JSB TAB EXPAND TABS JSB E.P SAVE PENDING LINE JSB ./R$ MOVE TABBED LINE TO PENDING LINE JSB OUTPT OUTPUT PENDING LINE EP JSB E.P RESTORE PREVIOUS PENDING LINE JMP NODE1 * * IF BELL (PROMPT) IS ON, TURN IT OFF. IF OFF, RESTORE IT. * ./CG LDA /+2 ALF,ALF STA /+2 REVERSE ORDER OF _ AND BELL. CLA,INA XOR / SHORTEN OR LENGTHEN STA / MESSAGE LENGTH. JMP NODE1 *** * * 'H' COMMAND -- PRINT HASH MARKS AND TAB STOPS * ./H JSB LST PRINT HASH MARKS DEF HASH DEF .35 * LDA TABCR CPA UNDEF JMP NODE1 NO TABS * LDA TABUF STA TBPNT TBLP LDB TBPNT,I GET NEXT TAB STOP CMB,INB,SZB,RSS JMP TBDIS LAST STOP, DISPLAY THEM ISZ TBPNT ADB TCCNT SSB,RSS JMP TBDIS STOP OUT OF ORDER INB,SZB,RSS JMP TOUT NO SPACES BEFORE 'T' STB TABSV * TBLP2 LDA SPACE JSB OUTCR OUTPUT SPACES ISZ TABSV JMP TBLP2 * TOUT LDA "T" JSB OUTCR OUTPUT A 'T' AT THE TAB POSITION JMP TBLP * TBDIS LDA TCCNT INA ARS CONVERT CHARS TO WORDS STA TCCNT JSB LST DISPLAY THE LINE DEF TBUFF,I DEF TCCNT JMP NODE1 * * .35 DEC 35 * HASH ASC 20,''''/''''1''''/''''2''''/''''3''''/''''4 ASC 15,''''/''''5''''/''''6''''/''''7 * SKP * EDIT PENDING LINE * SUBFUNCTIONS: * - INSERT CHARACTERS * - DELETE CHARACTERS * - REPLACE CHARACTERS (INITIAL MODE) * - TRUNCATE REMAINDER OF LINE * - EXTEND CURRENT LINE * - BREAK CURRENT LINE INTO TWO LINES * * * COPY PENDING LINE AND EDIT ('P') NEW LINE * ./O LDA PLNG SSA JMP DISPL END OF FILE - DO NOT COPY PENDING LINE JSB OUTPT OUTPUT PENDING LINE CLA STA PCCNT * * EDIT PENDING LINE * ./P LDA PLNG SSA IF END OF FILE JMP DISPL JUST PRINT 'EOF' LDA DLMTR USE DLMTR FOR TAB CPA UNDEF LDA SPACE OR SPACE, IF UNDEFINED STA TBFIL JSB TAB TAB THE LINE JSB SWPET SET UP INPUT BUFFER RPMOD LDA REPLA MODE STA PMODE INITIAL MODE IS REPLACE PNXT JSB ECH GET A CHARACTER JMP PFIN IF EOL THEN EXIT CPA REPLA JMP MODE REPLACE MODE CPA INSRT JMP MODE INSERT MODE CPA CANCL JMP MODE DELETE MODE CPA KLIP JMP KLIP2 TRUNCATE LINE CPA XTEND JMP FNDEN EXTEND LINE CPA BREAK JMP BRKLN SPLIT LINE IN TWO LDB PMODE GET THE CURRENT MODE CPB INSRT IF INSERT JMP PINS GO INSERT CPB CANCL IF DELETE JMP PDLS GO DELETE * CPA DLMTR IS IT REALLY COPY JMP PCOPY YES GO COPY JSB OUTCR OUTPUT THE NEW CHARACTER *** PDLS JSB PCH GET THE OLD CHARACTER NOP IGNOR EOL JMP PNXT BURN THE OLD AND GO GET THE NEXT *** PCOPY JSB PCH GET THE CURRENT CHARACTER LDA SPACE USE BLANK IF UNDEFINED JMP PINS2 *** PINS CPA DLMTR INSERT SPACES FOR LDA SPACE DELIMITER PINS2 JSB OUTCR SEND IT OUT JMP PNXT GO PROCESS THE NEXT CHAR. *** PFIN JSB PCH MOVE THE REST JMP ./RP OF THE LINE JSB OUTCR TO THE OUTPUT JMP PFIN BUFFER *** KLIP2 LDA PLNG STA PCCNT JMP RPMOD * * PMODE NOP SPCNT NOP *** ./RP JSB ./R$ REPLACE PENDING LINE LDA COMND CPA "C" JSB TR IF C COMMAND OUTPUT PENDING LINE JMP DISPL DISPLAY NEW PENDING LINE *** FNDEN CLA STA SPCNT NO BLANKS SO FAR PNXT2 JSB PCH COPY ALL CHARACTERS JMP TRAIL END OF PENDING LINE CPA SPACE JMP BMPSP CHECK FOR TRAILING BLANKS JSB OUTCR JMP FNDEN BMPSP ISZ SPCNT BUMP COUNT OF TRAILING SPACES JSB OUTCR JMP PNXT2 TRAIL LDA SPCNT SUBTRACT TRAILING BLANKS CMA,INA ADA TCCNT FROM THE OUTPUT CHARACTER COUNT STA TCCNT JMP RPMOD *** BRKLN LDA PCCNT STA STLN SAVE CURRENT LINE COUNTERS LDA PLNG STA ENLN CLA STA EXFLG EXCHANGE WOULD MODIFY SAVED LINE JSB ./R$ JSB OUTPT OUTPUT THE FIRST HALF JSB ./R$ LDA STLN STA PCCNT RESTORE CURRENT LINE COUNTERS LDA ENLN STA PLNG CLA STA TCCNT JMP RPMOD * SKP * * MERGE FILE - PARTIAL FILES MERGED BY LINE NUMBER. * MAY BE USED TO RECOVER FROM ACCIDENTAL DELETE. * ./M JSB SC.CR PARSE FILENAME DEF FNAME JMP ER002 NAME MUST BE SPECIFIED JSB NUMIN GET STARTING LINE SZA,RSS CLA,INA DEFAULT TO START OF FILE STA STLN JSB NUMIN GET END LINE STA ENLN DEFAULT TO END OF FILE JSB INSRC OPEN MERGE FILE CLA STA SC.CR SET LINE COUNT TO ZERO .M1 JSB RDM READ A LINE JSB FMP? CHECK FOR ERRORS DEF ENDM JSB BRK? TEST BREAK FLAG DEF ENDM ISZ SC.CR LDA SC.CR CPA STLN START MERGE? RSS YES JMP .M1 NO .M2 JSB OUTPT COPY TO DESTINATION JSB FMP? JUMP IF ERROR DEF ENDM JSB BRK? TEST BREAK FLAG DEF ENDM QUIT LDA SC.CR CPA ENLN END MERGE? JMP ENDM YES JSB RDM READ NEXT LINE ISZ SC.CR BUMP LINE COUNT JMP .M2 * * ENDM JSB CLOSE CLOSE MERGE FILE DEF *+2 DEF DCBL ENDER JSB FMPER DEF FNAME JMP READ1 READ NEXT LINE OF SOURCE *** STLN NOP ENLN NOP * SKP * * 'B' COMMAND - SEARCH FROM START OF FILE * ./B JSB TAB EXPAND TABS JSB M.T MOVE NEW PATTERN TO MATCH BUFFER JSB ./B1 PERFORM TRANSFER JSB READE READ FIRST LINE JMP COMP@ START SEARCH * * ./A ABORTS EXECUTION * SOURCE FILES AND SCRATCH FILES NOT PURGED * ./A JSB ECH IF ANY CHARACTERS RSS FOLLOWING THE "A" JMP ER001 RETURN TO SYNTAX INSTEAD OF ABORT ./AB JSB ERROR PRINT MESSAGE DEF ABORT DEC 7 JMP OUT ABORT ASC 7,XXXXX ABORTED SKP * *./E END OF EDITOR COMMAND * EC CREATES A NEW FILE * ER REPLACES AN EXISTING FILE (DEFAULT = ORIGINAL INPUT FILE) * EN RENAMES THE CURRENT OUTPUT SCRATCH FILE * ./E JSB CAPS GET NEXT CHAR OF COMMAND JMP ER001 NONE, ILLEGAL CPA "C" IF C JMP CRFIL GO TO CREATE FILE CPA "P" JMP CHEKP PURGE ORIGINAL, THEN CREATE NEW FILE CPA "R" IF R JMP CHEKR GO TO REPLACE FILE CPA "N" IF N RSS GO TO RENAME FILE JMP ER001 OTHERWISE GO TO ER001 * JSB SC.CR PARSE FILE NAME DEF FNAME JMP ER002 NAME MUST BE SPECIFIED * JSB ./B1 ROLL OVER FILE JSB CLOZE CLOSE THE INPUT FILE DEF DCBI,I DEF NAMI,I JSB FMP? JUMP IF ERROR DEF DISPL * JSB NAMF RENAME INPUT FILE DEF *+7 DEF DCBI,I DEF RUBSH DEF NAMI,I INPUT FILE NAME DEF FNAME DEF FSECR SECURITY DEF FCART CART. REF. SSA,RSS JMP OUT SUCCESSFUL RENAME JMP FMPC ERROR * CRFIL JSB SC.CR PARSE FILE NAME DEF FNAME JMP ER002 NAME MUST BE SPECIFIED * JSB CRSUB CHECK TYPE AND SIZE * * CRETE JSB CREAT CREATE NEW FILE DEF *+9 DEF DCBO,I DEF RUBSH DEF FNAME DEF FSIZE DEF FTYPE DEF FSECR DEF FCART DEF DCBSZ SSA,RSS JMP SW1 SWITCH THE NAME POINTER FMPE JSB FMPER PRINT THE ERROR DEF FNAME JMP FMPEX ERROR * BLOKS NOP .4 DEC 4 * CHEKP JSB SC.CR PARSE FILE NAME DEF FNAME RSS JMP PFILE NAME SPECIFIED LDB INPUT SZB,RSS JMP ER002 ERROR IF NO NAME ENTERED ORIGINALLY * JSB MVW USE SOURCE FILE NAME DEF INPUT DEF FNAME DEC 10 * CLA STA FSIZE USE DEFAULT SIZE, NOT ORIGINAL SIZE * PFILE JSB CRSUB CHECK TYPE AND SIZE * JSB PURGE PURGE THE OLD FILE DEF PER3 DEF DCBO,I DEF RUBSH DEF FNAME DEF FSECR DEF FCART * PER3 SSA CPA M6 JMP CRETE FILE NOT FOUND OR SUCCESSFULLY PURGED JMP FMPE PRINT ANY ERROR EXCEPT 'FILE NOT FOUND' * * * * CRSUB NOP CHECK FILE TYPE AND SIZE LDA FCODE RAR SLA,RSS JMP RPFIL NUMERIC NAMR, STORE ON LU * LDA FTYPE CPA .1 JMP ER006 WRONG FILE TYPE CPA .2 JMP ER006 WRONG FILE TYPE * JSB ./B1 COMPLETE TRANSFER TO OUTPUT FILE LDA FSIZE SZA IF NO. OF BLOCKS REQUESTED IS ZERO SSA OR NEGATIVE LDA BLOKS DEFAULT TO ACTUAL SIZE OF FILE STA FSIZE * LDA FTYPE SZA,RSS LDA .4 DEFAULT TO TYPE 4 STA FTYPE * JSB CLOZE CLOSE THE OUTPUT FILE DEF DCBO,I DEF NAMO,I JSB FMP? JUMP IF ERROR DEF DISPL JMP CRSUB,I * * * * CHEKR JSB SC.CR PARSE FILE NAME DEF FNAME RSS NO NAME SPECIFIED JMP RPFIL LDB INPUT DEFAULT TO INPUT FILE NAME SZB,RSS ERROR IF NO NAME ENTERED ORIGINALLY JMP ER002 JSB MVW MOVE NAME TO FNAME DEF INPUT DFNAM DEF FNAME .10 DEC 10 * RPFIL JSB ./B1 COMPLETE TRANSFER TO OUTPUT FILE JSB CLOZE CLOSE THE OUTPUT SCRATCH FILE DEF DCBO,I DEF NAMO,I JSB FMP? JUMP IF ERROR DEF DISPL * JSB OPENW OPEN REPLACE FILE DEF DCBO,I DEF RUBSH DEF FNAME DEF ZERO DEF FSECR DEF FCART DEF DCBSZ SSA TEST FOR ERRORS DURING CALL JMP FMPE * SW1 LDA NAMO SAVE THE OUTPUT NAME POINTER STA BLOKS LDA DFNAM STA NAMO SET UP NEW POINTER WRITR JSB READ READ FIRST RECORD JSB WRITE MOVE INPUT FILE TO OUTPUT FILE JSB FMP? JUMP IF ERROR DEF SW2 LDA PLNG SSA,RSS JMP WRITR JSB CLOZE CLOSE THE OUTPUT FILE DEF DCBO,I DEF NAMO,I JSB FMP? JUMP IF ERROR DEF SW2 * * OUT CLA STA TTY JSB CLOZE CLOSE OUTPUT DCB DEF DCBO,I DEF NAMO,I JSB CLOZE CLOSE INPUT DCB DEF DCBI,I DEF NAMI,I JSB CLOZE CLOSE COMMAND FILE DEF DCBE DEF ENAME * JSB LCLOZ CLOSE LIST FILE * JSB CLOZE CLOSE SCRATCH DCB HEADER DEF DCBSH DEF SF2 JSB CLOZE CLOSE INPUT DCB HEADER DEF DCBIH DEF INPUT JSB FMP? JUMP IF ERROR DEF NOPRG * JSB PURGE PURGE THE INPUT FILE DEF PER1 DEF DCBE DEF RUBSH DEF SF1 DEF ZERO DEF SCART * PER1 CPA M6 JMP *+3 JSB FMPER PRINT ANY ERRORS DEF SF1 * JSB PURGE PURGE THE OUTPUT SCRATCH FILE DEF PER2 DEF DCBE DEF RUBSH DEF SF2 DEF ZERO DEF SCART * PER2 CPA M6 JMP *+3 JSB FMPER PRINT ANY ERRORS DEF SF2 * NOPRG JSB LIMEM DEF *+2 DEF M1 RELEASE MEMORY * JSB REIO WRITE TERMINATION MESSAGE DEF *+5 DEF .2 DEF LOG DEF END DEF .6 * STOP JSB EXEC TERMINATE THE PROGRAM DEF *+2 DEF .6 * END ASC 6,END OF EDIT * * CLOZE NOP CLOSE FILE & PRINT SERIOUS ERRORS LDA CLOZE,I ISZ CLOZE STA CLDCB LDA CLOZE,I ISZ CLOZE STA CLNAM JSB CLOSE CLOSE THE FILE DEF *+2 CLDCB NOP CPA M11 CLA FILE ALREADY CLOSED JSB FMPER PRINT ANY OTHER ERRORS CLNAM NOP JMP CLOZE,I * M11 DEC -11 * SW2 LDA BLOKS RESTORE THE OUTPUT FILE NAME POINTER STA NAMO JMP FMPEX * SKP * * '!' COMMAND - PRINT NAMES OF INPUT AND SCRATCH FILES * ./! CLA STA LIST JSB NLSLU CHECK FOR NEW LIST DEVICE JSB NLSLU (ALLOW FOR COMMA BEFORE FILE NAME) LDA INPUT SZA,RSS JMP DEF NO INPUT FILE - DO NOT PRINT * JSB NAME MOVE THE FILE NAME DEF INPUT DEF SFIL+4 JSB LST PRINT INPUT FILE NAME DEF SFIL DEF .7 * DEF JSB NAME MOVE INFILE NAME TO MESSAGE DEF NAMI,I DEF MSG+4 JSB NAME MOVE OUTFILE NAME TO MESSAGE DEF NAMO,I DEF MSG+12 JSB LST PRINT MESSAGE DEF MSG DEF .15 JMP NODE1 * SFIL ASC 7,SOURCE= XXXXXX MSG ASC 15,INFILE= XXXXXX OUTFILE= XXXXXX * * SKP * * '$' COMMAND - DISPLAY OR CHANGE SPECIAL CHARACTERS * ./$ LDA TABCR STA TABSV SAVE THE OLD TAB CHARACTER * ./$0 JSB CAPS FETCH THE NAME JMP ./$1 NO NAMES, PRINT VALUES STA B MOVE NAME TO B-REG JSB NXCHR FETCH THE VALUE LDA UNDEF NO VALUE FOR NAME CPB "T" STA TABCR 'TAB' CHARACTER CPB "W" STA DLMTR 'WINDOW' CHARACTER CPB "F" STA INDEF 'FREE FIELD' CHARACTER CPB "X" STA XXXXX 'DON'T CARE' CHARACTER CPB "N" STA NOT 'NOT' CHARACTER CPB "Z" STA ZLNG 'ZERO LENGTH' CHARACTER CPB "C" STA TERM 'COMMAND TERMINATOR' CHARACTER CPB "I" STA INSRT 'INSERT' CHARACTER CPB "D" STA CANCL 'DELETE' CHARACTER CPB "R" STA REPLA 'REPLACE' CHARACTER CPB "K" STA KLIP 'TRUNCATE' CHARACTER CPB "B" STA BREAK 'BREAK' CHARACTER CPB "E" STA XTEND 'EXTEND' CHARACTER CPA UNDEF JMP ./$0 COMMA ALREADY READ JSB NXCHR BY-PASS THE COMMA JMP ./$0 CONTINUE WITH NEXT CHARACTER JMP *-2 * ./$1 LDA D./$2 STA BASE JSB SPECL TABCR NOP 'TAB' CHARACTER JSB SPECL DLMTR NOP 'WINDOW' CHARACTER JSB SPECL INDEF NOP 'FREE FIELD' CHARACTER JSB SPECL XXXXX NOP 'DONT CARE' CHARACTER JSB SPECL NOT NOP 'NOT' CHARACTER JSB SPECL ZLNG NOP 'ZERO-LENGTH RECORD' CHARACTER JSB SPECL TERM NOP 'COMMAND TERMINATOR' CHARACTER * JSB LST PRINT FIRST LINE D./$2 DEF ./$2 DEF .15 * * * LDA D./$3 STA BASE JSB SPECL INSRT NOP 'INSERT' CHARACTER JSB SPECL CANCL NOP 'DELETE' CHARACTER JSB SPECL REPLA NOP 'REPLACE' CHARACTER JSB SPECL KLIP NOP 'TRUNCATE' CHARACTER JSB SPECL BREAK NOP 'BREAK' CHARACTER JSB SPECL XTEND NOP 'EXTEND' CHARACTER JSB LST PRINT THE LINE D./$3 DEF ./$3 DEF .13 * * LDA TABCR CPA TABSV CHECK FOR [T] CHARACTER CHANGED JMP NODE1 NO NEED TO CHANGE TERMINAL TAB STOPS * LDB TTY CHECK FOR INTERACTIVE INPUT CPA %I CHECK FOR [T]= SZB JMP NODE1 NO NEED TO CHANGE TERMINAL TAB STOPS * JSB REIO CLEAR ALL TERMINAL TAB STOPS DEF RTN21 DEF .2 DEF LOG DEF CLRTB DEF M3 RTN21 LDA TABUF STA TBPNT TSTLP LDA TBPNT,I GET NEXT TAB STOP SZA,RSS JMP NODE1 END OF LIST * ISZ TBPNT INA BUMP TO PHYSICAL COLUMN # STA TABSV * JSB KCVT CONVERT COLUMN NUMBER TO ASCII DEF *+2 DEF TABSV STA SETTB+2 * JSB REIO SET THE TAB DEF RTN22 DEF .2 DEF LOG DEF SETTB DEF M11 RTN22 JMP TSTLP * CLRTB OCT 15463 3 ASC 1,_ NO CR-LF * SETTB OCT 15446 & OCT 60440 ASC 1,XX COLUMN NUMBER OCT 41433 C OCT 30415 1 ASC 1,_ NO CR-LF * * * TABSV NOP %I OCT 11 "=." OCT 36400 "%@" ASC 1,%@ * ./$2 ASC 15, T=; W=/ F=\ X?? N?? Z%@ C?? ./$3 ASC 13, I%S D%C R%R K%T B%B E%X * * SPECL NOP SET TO DISPLAY SPECIAL CHARACTER ISZ BASE LDA SPECL,I AND B37 CPA SPECL,I JMP CNTRL CONTROL CHARACTER LDA SPECL,I IOR "=." SPEX STA BASE,I ISZ BASE ISZ SPECL JMP SPECL,I * CNTRL IOR "%@" JMP SPEX * B37 OCT 37 * * SKP * * DISPLAY THE CURRENT LINE NUMBER IN THE INPUT & OUTPUT FILES, * THE NO. OF BLOCKS IN OUTPUT FILE, & NO. OF CHARACTERS IN PENDING LINE . * ./N CLA STA LIST STA TCCNT JSB NLSLU SET UP LIST DEVICE JSB NLSLU (ALLOW FOR COMMA BEFORE FILE NAME) LDA "N" JSB OUTCR OUTPUT N LDA "=" JSB OUTCR OUTPUT = LDA LINES CLB JSB DEC CONVERT LINE NUMBER TO ASCII LDA SPACE JSB OUTCR OUTPUT SPACE LDA "O" JSB OUTCR OUTPUT O LDA "=" JSB OUTCR OUTPUT = LDA T#REC JSB STATO OUTPUT STATUS LINE * CLA RESET TBUFF TO ACCEPT THE NEXT LINE OF OUTPUT STA TCCNT LDA "B" JSB OUTCR OUTPUT B LDA "=" JSB OUTCR OUTPUT = JSB BLKS? COMPUTE THE SIZE OF THE OUTPUT FILE CLB JSB DEC CONVERT TO AN ASCII STRING IN TBUFF LDA SPACE JSB OUTCR OUTPUT SPACE LDA "C" JSB OUTCR OUTPUT C LDA "=" JSB OUTCR OUTPUT = LDA PLNG LOAD # CHARACTERS IN PENDING LINE SSA IF EOF, THEN PRINT "0" CLA JSB STATO OUTPUT STATUS LINE * CLA STA TCCNT ZERO THE COUNT LDA "W" JSB OUTCR OUTPUT W LDA "=" JSB OUTCR OUTPUT = LDA WIND1 INA CLB JSB DEC CONVERT WINDOW TO ASCII LDA SPACE JSB OUTCR OUTPUT SPACE LDA SPACE JSB OUTCR OUTPUT SPACE LDA SPACE JSB OUTCR OUTPUT SPACE LDA WIND2 CMA,INA JSB STATO OUTPUT STATUS LINE JMP NODE1 * * * STATO NOP CLB JSB DEC CONVERT TO ASCII LDA TCCNT INA ARS CONVERT CHARACTER COUNT TO WORDS STA TCCNT JSB LST PRINT LINE DEF TBUFF,I DEF TCCNT JMP STATO,I * SKP * * MERGE FILE - SEARCH FOR FIRST & LAST LINES BY PATTERN * ./S JSB SC.CR PARSE FILE NAME DEF FNAME JMP ER002 NAME MUST BE ENTERED JSB TTYIP ASK FOR FIRST PATTERN DEF FROM JSB TAB EXPAND TABS JSB M.T MOVE TO MATCH BUFFER JSB TTYIP ASK FOR SECOND PATTERN DEF TO JSB INSRC OPEN MERGE FILE ./S2 JSB RDM READ A LINE JSB MACH? COMPARE PENDING LINE TO MATCH BUFFER JMP ./S2 NO MATCH - CONTINUE SEARCH JSB LSTSB LIST MATCH JSB TAB EXPAND TABS FOR SECOND PATTERN JSB M.T MOVE TBUFF TO MATCH BUFFER ./S4 JSB OUTPT OUTPUT THE LINE JSB FMP? JUMP IF ERROR DEF ENDM JSB BRK? TEST BREAK FLAG DEF ENDM QUIT JSB RDM READ NEXT LINE JSB MACH? COMPARE PENDING LINE AND MATCH BUFFER JMP ./S4 NO MATCH - CONTINUE JSB LSTSB LIST MATCH JSB OUTPT WRITE LAST LINE JMP ENDM CLOSE MERGE FILE * * FROM DEC -3 ASC 2,1>_ STARTING PATTERN * TO DEC -3 ASC 2,2>_ ENDING PATTERN * SKP * * READ IN SPECIFIED LINES FROM HELP FILE. * ALL LINES STARTING WITH FIRST TWO CHARS OF COMMAND ARE DISPLAYED. * ./? LDA TTY SZA JMP NODE1 NOT INTERACTIVE, CANNOT USE DCBE JSB CAPS FETCH SECOND KEY CHARACTER LDA COMMA NO SECOND CHAR GIVEN ASSUME SUMMARY IOR "?." ADD "?" IN HIGH BYTE STA KEY CLA,INA STA ECCNT JSB NXCHR BYPASS COMMA RSS JMP *-2 NOT A COMMA, TRY AGAIN JSB NLSLU CHECK FOR NEW LIST DEVICE JSB E.P SAVE PENDING LINE JSB OPENW OPEN HELP FILE DEF DCBE DEF RUBSH DEF HLPNM DEF ZERO OPTION DEF ZERO SEC DEF ZERO CR DEF .128 SIZE CPA M6 JMP EP NOT FOUND, IGNORE COMMAND SSA JMP ER? ./?1 JSB READF READ FROM HELP FILE DEF RTN5 DEF DCBE DEF RUBSH DEF PBUFF,I DEF .75 DEF PLNG RTN5 JSB FMPER PRINT ANY ERRORS DEF HLPNM IOR PLNG SSA JMP END? ERROR OR END OF FILE CLB STB PCCNT LDA PLNG ALS STA PLNG MAKE CHARACTER COUNT * LDA PBUFF,I TEST KEY LDB SPSP STB PBUFF,I SUPPRESS PRINTING OF THE KEYWORD CPA KEY JSB LSTSB PRINT PENDING LINE JSB FMP? JUMP IF ERROR DEF END? JSB BRK? TEST BREAK FLAG DEF END? JMP ./?1 * "?." OCT 37400 KEY NOP COMMA OCT 54 * END? JSB CLOSE CLOSE HELP FILE DEF *+2 DEF DCBE ER? JSB FMPER DEF HLPNM JMP EP RESTORE PENDING LINE * M6 DEC -6 .75 DEC 75 * HED RTE EDITOR - SUBROUTINES * * NAME:./B1 * THIS ROUTINE POSITIONS TO THE FIRST LINE * IN THE OUTPUT FILE AND THEN DISABLES EXCHANGES. * CALLING SEQUENCE: * JSB ./B1 * ./B1 NOP LDA COMND CPA "E" JMP ./B2 PASS OVER ENTIRE SOURCE BEFORE EXIT CPA "M" JMP ./B2 IF "E", "M", OR "S" COMMAND CPA "S" JMP ./B2 * LDA EXFLG OR IF THE EXCHANGE FLAG IS SET SZA,RSS JMP BACK SIMPLY BACK UP * ./B2 JSB BRK? TEST BREAK FLAG DEF DISPL JSB OUTPT WRITE PENDING LINE TO OUTPUT FILE JSB FMP? JUMP IF ERROR DEF DISPL LDA PLNG SSA JMP RESET EOF JSB READ READ NEXT INPUT RECORD JMP ./B2 * RESET LDA PASS1 FIRST PASS? SZA JMP OPNS2 SET UP SECOND SCRATCH FILE PAS2 STA EXFLG DISABLE EXCHANGE STA LCOMF AND LIST * LDA DCBI SWAP INPUT-OUTPUT POINTERS LDB DCBO STA DCBO STB DCBI LDA NAMI LDB NAMO STA NAMO STB NAMI JSB RWNDI REWIND INPUT FILE BKOUT JSB BLKS? COMPUTE SIZE OF OUTPUT FILE STA BLOKS JSB RWNDO REWIND OUTPUT FILE JMP ./B1,I * * * BACK DLD T#WDS SZB,RSS SSA JMP ./B2 MORE THAN 77777B WORDS * LDB SLNG TRY TO BACK UP LDA DCBSZ CMA,INA SZB LDA SCNT AVAILABLE SPACE ON STACK CLO CLEAR OVERFLOW FLAG ADA T#WDS SEE IF THE ENTIRE OUTPUT FILE LDB PLNG WILL FIT IN THE INPUT DCB SSB JMP SKEOF INB BRS INCLUDING THE PENDING LINE ADA B SKEOF ADA T#REC AND ONE WORD PER RECORD SOS SSA,RSS JMP ./B2 WILL NOT FIT * JSB POSTI FREE UP THE INPUT BUFFER PUSHB JSB BRK? CHECK THE BREAK FLAG DEF WE WRITE AN EOF JSB PUSH PUSH THE PENDING LINE ONTO THE STACK JMP ./B2 STACK OVERFLOW (SHOULD NEVER GET HERE) JSB FMP? CHECK FOR FMP ERRORS DEF WE * JSB GET BACK UP ONE LINE JMP BKOUT START OF FILE, DONE JMP PUSHB * * OPNS2 JSB CLOSE CLOSE THE ORIGINAL FILE DEF *+2 DEF DCBI,I JSB FMPER PRINT ANY ERRORS DEF NAMI,I LDA DSCR2 SWITCH THE NAME POINTER STA NAMI JSB MVW AND MOVE THE DCB HEADER DEF DCBSH DEF DCBI,I DEC 16 JSB MVW ZERO THE SECOND COPY DEF ZERO DEF DCBSH DEC 16 CLA STA PASS1 JMP PAS2 SKP * * NAME:./R$ * SUBROUTINE TO REPLACE THE PENDING LINE * WITH THE LINE IN THE TERMINAL OUTPUT BUFFER. * BY SWAPPING THE BUFFER POINTERS. * CALLING SEQUENCE: * JSB ./R$ * ./R$ NOP LDB TCCNT MOVE NUMBER OF CHARACTERS IN TBUFF STB PLNG TO PENDING LINE LENGTH WORD LDA TBUFF LDB PBUFF SWAP STA PBUFF POINTERS STB TBUFF JMP ./R$,I SKP * * NAME:BLKS? * SUBROUTINE TO COMPUTE THE NUMBER OF BLOCKS IN * THE OUTPUT FILE. * CALLING SEQUENCE: * JSB BLKS? * * * BLKS? NOP COMPUTE NUMBER OF BLOCKS IN OUTPUT FILE LDA T#REC NUMBER OF RECORDS MPY .2 TWO LENGTH WORDS PER RECORD CLE,INA LDB T#WDS+1 ADA T#WDS ADD # OF DATA WORDS IN DESTINATION FILE SEZ INB CARRY INTO MSB DIV .128 DIVIDE INTO BLOCKS SZB INA PARTIAL BLOCK JMP BLKS?,I * * SKP * * NAME:BRK? * SUBROUTINE TO CHECK THE BREAK FLAG AND SAVE IT * FOR CHECKING BY THE COMMAND LOOP. * CALLING SEQUENCE: * JSB BRK? * DEF TRAP JUMPS HERE IF BREAK FLAG WAS SET * BRK? NOP CHECK THE BREAK FLAG JSB IFBRK DEF *+1 SZA JMP BRSET BREAK FLAG SET ISZ BRK? JMP BRK?,I * BRSET STA BRKFL SET THE EDITOR BREAK FLAG LDA BRK?,I JMP A,I * BRKFL NOP * SKP * * * NAME:CAPS * SUBROUTINE TO CONVERT COMMAND CHAR TO UPPER CASE. * CHARACTER UNCHANGED IF NOT LETTER (A-Z). * CALLING SEQUENCE: * JSB CAPS * >END OF BUFFER * >COMMAND CHAR IN A * CAPS NOP CONVERT COMMAND CHAR TO UPPER CASE JSB ECH GET NEXT CHAR JMP CAPS,I NONE ISZ CAPS BUMP RETURN STA SAVL SAVE IT ADA N141 MAKE AN "A" A ZERO SSA OUT OF RANGE? JMP CAPSO YES ADA N32 MAKE A "Z" A MINUS ONE SSA,RSS OUT OF RANGE? JMP CAPSO YES ADA B133 CONVERT TO UPPER CASE STA SAVL CAPSO LDA SAVL JMP CAPS,I N141 OCT -141 N32 OCT -32 SAVL NOP * SKP * * NAME:CCH * THIS ROUTINE FETCHES ONE CHARACTER FROM THE COMMAND STRING * CALLING SEQUENCE: * JSB CCH * >END OF LINE * >CHARACTER FOUND IN A * CCH NOP INPUT A CHARACTER FROM COMMAND BUFFER LDA CCCNT CPA CLNG JMP CCH,I NO MORE CHARACTERS ISZ CCCNT CLE,ERA ADA CBUFF JSB CH CPA TERM END OF COMMAND? JMP CCH,I YES ISZ CCH JMP CCH,I * SKP * * NAME:CH * SUBROUTINE TO FETCH A CHARACTER FROM A BUFFER * CALLING SEQUENCE: * LDA ADDRESS * SET E (0=HIGH BYTE 1=LOW BYTE) * JSB CH * >NEXT CHARACTER FROM BUFFER IN A * CH NOP LDA A,I FETCH WORD CONTAINING CHARACTER SEZ,RSS MOVE WANTED CHARACTER ALF,ALF TO LOWER BYTE AND LBYTE AND DELETE OTHER CHARACTER JMP CH,I SKP * * NAME:CHKN * SUBROUTINE TO CHECK THAT ALL PARAMETERS * OF A COMMAND ARE NUMERIC AND POSITIVE. * NUMIN PRINTS ER001 IF NOT ALL OKAY. * CALLING SEQUENCE: * JSB CHKN * CHKN NOP NPARA JSB NUMIN FETCH NEXT PARAM LDA ELNG IF END OF COMMAND CPA ECCNT THEN, ALL PARAMETERS CLA,INA,RSS WERE NUMERIC JMP NPARA ELSE, FETCH NEXT PARAM STA ECCNT RESET COUNT AND RETURN JMP CHKN,I * SKP * NAME: COMP * SUBROUTINE TO COMPARE PENDING LINE * TO ANY OTHER BUFFER. * CALLING SEQUENCE: * LDA BUFFER LENGTH * LDB BUFFER ADDRESS * JSB COMPR * >NO MATCH RETURN HERE * >MATCH RETURN HERE * COMPR NOP COMPARE PENDING LINE TO MATCH BUFFER STA MX.LN STB MX.BF CCB STB RSCN1 LDB PCCNT STB PCRST SAVE STARTING POSITION IN SOURCE CLB CLEAR STB WINDF WINDOW FLAG STB MX.CN STB FIRST STB RESCN STB NCNT STB NCNT$ STB PCCN$ STB MCCN$ CMPR0 STB MMCNT CMPR1 JSB MX.CH JMP EOM END OF MATCH BUFFER CPA INDEF JMP CMPR6 INDEFINITE CHARACTER CPA DLMTR WINDOW SPECIFIED JMP CMPR5 ON SEARCH CMPR7 ISZ RSCN1 CHECK FOR FIRST POSSIBLE RESCAN POINT JMP CMPR2 NO CCB ADB MX.CN YES, BACK UP ONE STB MXRST CMPR2 CPA NOT JMP NCHAR 'NOT' MODE STA B SAVE THE CHARACTER JSB PCH GET SOURCE CHARACTER. JMP ZCHK CHECK FOR ZERO LENGTH RECORD CPB XXXXX JMP CMPR3 'DONT CARE' CHAR MATCHES ANYTHING CPA B COMPARE WITH PATTERN JMP CMPR3 COMPARES LDA NCNT SLA JMP BMPMM 'NOT' MODE, NO MATCH ISZ FIRST FIRST CHARACTER AFTER [F] OR [W]? JMP IDEF NO, CHECK FOR RETRY ALLOWED * LDA PCCNT STA PCCN$ CCB ADB MX.CN BACK UP TO PREVIOUS MATCH CHARACTER IDEF2 CPA PLNG JMP COMPR,I END OF SOURCE STB MX.CN CPB MXRST STA PCRST RETRY FROM BEGINNING OF MATCH BUFFER LDB WINDF SZB,RSS JMP CMPR9 SKIP WINDOW CHECK ADA BWIND ADJUST WINDOW FOR PREVIOUS EXCHANGES ADA WIND2 SSA,RSS DO NOT RESCAN IF FLAG SET AND JMP COMPR,I NEXT CHAR PAST WINDOW CLB,INB,RSS SET FLAG AGAIN *** CMPR6 CLB * CMPR8 STB WINDF WINDOW FLAG * CMPR9 LDA MX.CN SET UP FOR INDEFINITE STA MCCN$ CHARACTER LDA NCNT SAVE 'NOT' CHARACTER COUNT STA NCNT$ FOR RESCAN CCA SAVE THE PATTERN LOCATION AND STA FIRST SET THE FIRST CHAR. FLAG STA RESCN ALLOW RESCAN JMP CMPR1 GO GET THE FIRST PATTERN CHARACTER. *** BMPMM ISZ MMCNT COUNT MISMATCHES IN 'NOT' MODE CMPR3 ISZ FIRST FIRST CHAR FOUND AFTER INDEF CHAR? JMP CMPR1 NO CONTINUE LDA PCCNT STA PCCN$ SAVE RESCAN POINTER LDB WINDF GET WINDOW FLAG AND SLB,RSS IF ONE SET TO TWO JMP CMPR1 ISZ WINDF ADA BWIND ADJUST WINDOW FOR PREVIOUS EXCHANGES ADA WIND2 ADA M1 SEE IF THE LAST CHAR SSA WAS IN THE WINDOW JMP CMPR1 WITHIN WINDOW JMP COMPR,I OUTSIDE WINDOW *** CMPR5 CLB,INB IS WINDOW CHARACTER CPB MX.CN THE FIRST CHAR. OF COMMAND? RSS YES -- CONTINUE JMP CMPR7 NO, IGNORE LDA PCCNT SZA JMP CMPR8 NOT FIRST CALL TO COMPR LDA WIND1 START SEARCH AT STA PCCNT BEGINNING OF WINDOW STA PCRST CMA,INA IF WINDOW ADA PLNG STARTS BEYOND SSA,RSS END OF LINE JMP CMPR8 LDA PLNG STA PCCNT SET TO END OF LINE STA PCRST JMP CMPR8 *** ZCHK CPB XXXXX IF 'DONT CARE' JMP CMPR3 THEN CONTINUE LDA NCNT SLA JMP BMPMM BUMP MISMATCH COUNTER * LDA PLNG CHECK FOR ZERO LENGTH RECORD SZA JMP COMPR,I NO CPB ZLNG IF LOOKING FOR ZERO-LENGTH RECORD, CMPR4 ISZ COMPR BUMP TO GOOD RETURN JMP COMPR,I * FIRST NOP * NCHAR LDB NCNT ISZ NCNT LDA MMCNT SLB IF 'NOT' MODE SZA AND ALL CHARACTERS MATCHED, CLB,RSS JMP IDEF THEN RESCAN THE SOURCE BUFFER JMP CMPR0 ELSE, CONTINUE SEARCH * * EOM LDB NCNT LDA MMCNT SLB IF 'NOT' MODE SZA AND ALL CHARACTERS MATCHED, JMP CMPR4 ISZ NCNT * IDEF ISZ RESCN JMP COMPR,I NO RETRY ALLOWED * LDA PCCN$ ANY CHARACTERS READ SO FAR? CPA PCCNT JMP CMPR1 NO, IGNORE 'MISMATCH' * STA PCCNT LDB NCNT$ STB NCNT RESET COUNTERS LDB MCCN$ JMP IDEF2 THEN RESCAN THE SOURCE BUFFER * MCCN$ NOP RESCN NOP MX.BF NOP MX.CN NOP MX.LN NOP MXRST NOP MMCNT NOP BWIND NOP WINDF NOP NCNT NOP RSCN1 NOP PCCN$ NOP NCNT$ NOP PCRST NOP * SKP * NAME:CONVT * SUBROUTINE TO CONVERT THE DECIMAL DIGIT IN THE * A-REGISTER TO ASCII AND OUTPUT TO TBUFF. * ONLY SUPPRESS LEADING ZEROES IF PUT AT START OF TBUFF * CALLING SEQUENCE: * LDA DIGIT FOR THIS DECIMAL PLACE * LDB VALUE OF NUMBER LESS THAN THIS PLACE * JSB CONVT * REGISTERS ON RETURN: * A:REMAINDER FROM LAST DIVIDE * B:ZERO * CONVT NOP STB DIRCT SAVE REMAINDER SZA IF JMP CONV1 LEADING CPA TCCNT ZERO JMP CONV2 DO NOT OUTPUT IT CONV1 IOR B60 CONVERT NUMBER TO ASCII JSB OUTCR MOVE CHARACTER TO BUFFER CONV2 CLB SET REGISTERS UP LDA DIRCT FOR NEXT DIVIDE JMP CONVT,I B60 OCT 60 * SKP * * NAME:CXT * COMPARES THE PENDING LINE TO AN OLD PATTERN AND * EXCHANGES IT FOR A NEW PATTERN, IF A MATCH IS FOUND. * CALLING SEQUENCE: * JSB CXT * CXT NOP THIS ROUTINE DOES ALL THE CLA MATCHING IN THE SOURCE BUFFER STA PCCNT CPA UNCON JMP CXT0 CONDITIONAL EXCHANGE JMP CXTUC CXT0 STA MATCH NO MATCH SO FAR LDB PLNG STB PSAVE SAVE ORIGINAL LENGTH CXT1 STA BWIND RESET WINDOW BIAS LDA XLNG LDB XYBUF USE EXCHANGE BUFFER JSB COMPR COMPARE TO PENDING LINE JMP CXT,I NO MATCH LDA XLIST SET LIST STA MATCH FLAG LDA PCCNT SAVE CURRENT STA RSCN1 POSITION IN SOURCE CLA RESET STA PCCNT SOURCE CHARACTER COUNTER STA TCCNT OUTPUT CHARACTER COUNTER STA YCCNT REPLACE CHARACTER COUNTER * LDA PCRST MOVE ANY CHARACTERS BEFORE THE MATCH CMA,INA,SZA,RSS JMP RPC1 STA T2 RPC0 JSB PCH GET CHARACTERS JMP RPC1 (SHOULD NEVER GET HERE) JSB OUTCR OUTPUT TO TEMPORARY BUFFER ISZ T2 JMP RPC0 * RPC1 LDA PCRST CMA,INA ADA RSCN1 CMA,INA,SZA,RSS JMP RPC3 NULL MATCH PATTERN STA T2 RPC2 JSB PCH MOVE LDA SPACE DEFAULT TO SPACE STA B JSB YCH REPLACE PENDING CHARACTER JMP RPC6 WITH REPLACEMENT CHARACTERS CPA XXXXX UNLESS "DON'T CHANGE" WAS SPECIFIED LDA B JSB OUTCR TO OUTPUT RPC6 ISZ T2 JMP RPC2 RPC3 JSB YCH MOVE EXTRA CHARACTERS TO OUTPUT BUFFER JMP RPC4 CPA XXXXX JMP RPC3 'DONT CHANGE' JSB OUTCR JMP RPC3 * RPC4 LDA TCCNT SAVE POSITION STA T2 FOR CONTINUATION OF SEARCH * RPC5 JSB PCH MOVE REMAINDER JMP ENDRP OF SOURCE LINE JSB OUTCR TO OUTPUT JMP RPC5 * ENDRP LDA RSCN1 SZA IF NULL MATCH PATTERN CPA PLNG OR AT END OF SOURCE JMP ENDCX END THE EXCHANGE OPERATION JSB ./R$ REPLACE OLD SOURCE LINE LDA T2 STA PCCNT LDA PLNG COMPUTE CMA,INA BIAS FOR ADA PSAVE UPPER BOUND JMP CXT1 CONTINUE SEARCH * ENDCX JSB ./R$ REPLACE LINE JMP CXT,I AND RETURN * PSAVE NOP * * CODE FOR UNCONDITIONAL REPLACE. * CXTUC STA YCCNT STA TCCNT ZERO BUFFER COUNTERS LDA XLIST TO LIST OR NOT STA MATCH TO LIST? LDA WIND1 CMA,INA,SZA,RSS JMP CXTU5 STA T1 CXTU1 JSB PCH MOVE SOURCE CHARACTERS LDA SPACE PRECEEDING WINDOW JSB OUTCR TO OUTPUT. ISZ T1 JMP CXTU1 * CXTU5 CCA ADA XLNG DO NOT COUNT WINDOW CHARACTER CMA,INA,SZA,RSS JMP CXTU3 NULL MATCH FIELD STA T1 CXTU2 JSB PCH LDA SPACE DEFAULT TO SPACE STA B JSB YCH GET REPLACEMENT CHARACTER JMP CXTU6 NO MORE CPA XXXXX LDA B "DON'T CHANGE" JSB OUTCR OUTPUT TO BUFFER CXTU6 ISZ T1 JMP CXTU2 * CXTU3 JSB YCH MOVE REPLACEMENT CHARACTERS JMP CXTU4 TO OUTPUT. CPA XXXXX JMP CXTU3 'DONT CHANGE' JSB OUTCR JMP CXTU3 * CXTU4 JSB PCH MOVE REMAINDER OF RECORD JMP ENDCX TO OUTPUT JSB OUTCR JMP CXTU4 * MATCH NOP YCCNT NOP T1 NOP T2 NOP * SKP * * NAME:DEC * SUBROUTINE TO CONVERT A DOUBLE PRECISION * INTEGER TO A CHARACTER STRING IN TBUFF. * CALLING SEQUENCE: * DLD NUMBER TO BE CONVERTED * JSB DEC * DEC NOP CLE,SZB,RSS >65K? JMP SNGLP DIV .10K WORK ON EXCESS FIRST STB READ SAVE REMAINDER FOR NEXT PASS. CLB JSB DEC4 LDA READ CCE SKIP DIV .10K THIS TIME SNGLP JSB DEC4 JMP DEC,I SKP * * NAME:DEC4 * SUBROUTINE TO CONVERT THE DECIMAL NUMBER IN THE * A-REGISTER TO A CHARACTER STRING IN THE TERMINAL * OUTPUT BUFFER. IF E-REG=0, THE NUMBER IS ASSUMED * TO BE A SINGLE PRECISION INTEGER OR THE MOST * SIGNIFICANT BITS OF A DOUBLE PRECISION INTEGER. * IF E-REG=1, THE NUMBER IS ASSUMED TO BE THE * SECOND WORD OF A DOUBLE PRECISION INTEGER. * CALLING SEQUENCE: * SET E-REG * LDA NUMBER TO BE CONVERTED * JSB DEC4 * REGISTERS ON RETURN: * A:ZERO * B:ZERO * DEC4 NOP SEZ IF NUMBER >65K, SKIP JMP THOU FIRST DIVIDE, PASS 2. DIV .10K OUTPUT TEN THOUSANDS JSB CONVT DIGIT THOU DIV .1000 OUTPUT THOUSANDS JSB CONVT DIGIT DIV .100 OUTPUT HUNDREDS JSB CONVT DIGIT DIV .10 OUTPUT TENS JSB CONVT DIGIT AND JSB CONVT ONES DIGIT JMP DEC4,I * SKP * NAME:DIRCT * SUBROUTINE TO FIND A DIRECT ADDRESS * CALLING SEQUENCE: * LDB ADDRESS * JSB DIRCT * REGISTERS ON RETURN: * A:UNCHANGED * B:DIRECT ADDRESS * DIRCT NOP SSB,RSS JMP DIRCT,I DONE ELB,CLE,ERB MASK OFF INDIRECT BIT LDB B,I JMP DIRCT+1 SKP * * NAME:ECH * SUBROUTINE TO RETURN NEXT COMMAND CHARACTER * CALLING SEQUENCE: * JSB ECH * >END OF BUFFER RETURN HERE * >CHARACTER RETURNED IN A * ECH NOP LDA ECCNT # CHARACTERS ALREADY READ CPA ELNG # CHARACTERS IN BUFFER JMP ECH,I END OF VALID DATA ISZ ECCNT ISZ ECH BUMP TO NORMAL RETURN CLE,ERA CONVERT TO WORDS ADA EBUFF ADD BASE ADDRESS JSB CH FETCH CHARACTER FROM BUFFER JMP ECH,I * SKP * * NAME: E.P * SUBROUTINE TO EXCHANGE EBUFF AND PBUFF BY * SWAPPING BUFFER POINTERS AND LENGTHS. * CALLING SEQUENCE: * JSB E.P * E.P NOP SWAP COMMAND BUFFER AND PENDING LINE LDA EBUFF LDB PBUFF STA PBUFF STB EBUFF LDA ELNG LDB PLNG STA PLNG STB ELNG JMP E.P,I * SKP * * * ER006 JSB ERROR PRINT 'WRONG FILE TYPE' DEF MS006 DEC 12 JMP NODE1 * ER004 JSB ERROR PRINT 'DELIMITER MISSING' DEF MS004 DEC 13 JMP NODE1 * * ER002 JSB ERROR PRINT 'FILE NAME MISSING' DEF MS002 DEC 13 JMP NODE1 * * ER001 JSB ERROR PRINT 'INVALID COMMAND' DEF MS001 DEC 12 JMP NODE1 * * ER000 JSB ERROR PRINT 'INVALID PARAMETER' DEF MS000 DEC 13 JMP NODE1 * * MS000 ASC 13,XXXXX 0-INVALID PARAMETER MS001 ASC 12,XXXXX 1-INVALID COMMAND MS002 ASC 13,XXXXX 2-FILE NAME MISSING MS004 ASC 13,XXXXX 4-DELIMITER MISSING MS006 ASC 12,XXXXX 6-WRONG FILE TYPE * SKP * * NAME:ERROR * SUBROUTINE TO PRINT AN ERROR MESSAGE ON THE CONSOLE. * PROGRAM IS ABORTED IF COMMAND INPUT * IS NOT FROM A TERMINAL. * CALLING SEQUENCE: * JSB ERROR * DEF BUFFER * MESSAGE LENGTH IN WORDS * ERROR NOP LDA ERROR,I ISZ ERROR STA ERMEQ * JSB REIO PRINT ERROR ON SESSION CONSOLE DEF *+5 DEF .2 DEF LOG ERMEQ NOP ADDRESS DEF ERROR,I COUNT * LDA TTY SZA JMP OUT NON-INTERACTIVE, ABORT EDIT STA CCCNT STA LFLAG STA CLNG SET TO READ NEXT COMMAND CCA STA RPCNT SET TO JUMP OUT OF REPEAT LOOP ISZ ERROR JMP ERROR,I * SKP * * * NAME:EXCH * THIS ROUTINE EXCHANGES AN OLD PATTERN FOR A * NEW PATTERN IF THE EXCHANGE FLAG IS SET. * CHANGES ARE LISTED. * CALLING SEQUENCE: * JSB EXCH * EXCH NOP EXCHANGE AND LIST CHANGES LDA EXFLG SZA,RSS JMP EXCH,I EXCHANGE NOT ENABLED JSB CXT DO THE EXCHANGE LDA MATCH SZA,RSS JMP EXCH,I NO MATCH * LDA LCOMF SZA,RSS AVOID DUPLICATE LISTING JSB LSTSB LIST THE NEW LINE JMP EXCH,I * SKP * * NAME:FMP? * THIS ROUTINE CHECKS THE FMP ERROR ACCUMULATOR. * IF AN FMP ERROR HAS OCCURED SINCE THIS ROUTINE * WAS LAST CALLED, THE PASSED ENTRY POINT IS USED * AS AN ERROR RECOVERY ROUTINE. * CALLING SEQUENCE: * JSB FMP? * DEF ENTRY * >RETURNS HERE IF NO ERROR * OTHERWISE JUMPS TO * * FMP? NOP CHECK FMP ERROR ACCUMULATOR CLA LDB FMP?,I ISZ FMP? CPA FMP JMP FMP?,I NO ERROR, RETURN STA FMP CLEAR THE ACCUMULATOR JMP B,I JUMP TO ERROR RETURN * SKP * * NAME:FMPER * SUBROUTINE TO PRINT OUT ALL FILE MANAGER ERRORS. * ANY ERROR SETS THE ERROR ACCUMULATOR FLAG. * CALLING SEQUENCE: * LDA ERROR CODE * JSB FMPER * DEF FILE NAME * >ERROR CODE IN A * FMPER NOP SSA,RSS JMP FMPOK NO ERROR, RETURN STA FMP ERROR ACCUMULATOR CPA SIGN JMP FMPOK DO NOT PRINT ERROR MESSAGE CLB,INB STB TCCNT SET UP OUTPUT BUFFER COUNT CMA,INA COMPLEMENT ERROR NUMBER CLB JSB DEC CONVERT TO ASCII LDB TBUFF INB LDA B,I GET FIRST DIGIT XOR B1640 CHANGE '0' TO '-' STA MSGP+5 INB LDA B,I STA MSGP+6 PUT LAST TWO DIGITS IN MESSAGE * LDA FMPER,I STA FMPNM JSB NAME MOVE THE NAME TO THE MESSAGE FMPNM NOP DEF MSGP+9 JSB ERROR PRINT ERROR MESSAGE DEF MSGP .12 DEC 12 LDA FMP FETCH ERROR CODE FMPOK ISZ FMPER JMP FMPER,I * * * FMP NOP LU ASC 1,LU SPSP ASC 1, * * * MSGP ASC 12,FMP ERROR -XXX ON XXXXXX * FMPC JSB FMPER PRINT FILE MANAGER ERROR DEF FNAME JSB OPENW RE-OPEN INPUT FILE DEF DCBI,I DEF RUBSH DEF NAMI,I DEF ZERO DEF ZERO DEF SCART DEF DCBSZ JSB FMPER PRINT ANY ERRORS DEF NAMI,I JMP READ1 THEN GET NEXT COMMAND * FMPEX JSB OPENW RE-OPEN THE OUTPUT SCRATCH FILE DEF DCBO,I DEF RUBSH DEF NAMO,I DEF ZERO DEF ZERO DEF SCART DEF DCBSZ JSB FMPER DEF NAMO,I JMP RWND READ FIRST LINE * SKP * * NAME:GET * SUBROUTINE TO READ A RECORD FROM THE OUTPUT FILE * TO THE PENDING LINE BUFFER. * CALLING SEQUENCE: * JSB GET * >START OF FILE, NO RECORD INPUT * >RECORD AVAILABLE * GET NOP GET A LINE FROM THE OUTPUT FILE LDA T#REC ADJUST CURRENT LINE NUMBER STA LINES JSB POSNT BACKSPACE ONE RECORD DEF RTN16 DEF DCBO,I DEF RUBSH DEF M1 RTN16 CPA M12 JMP GET,I START OF FILE, EXIT * JSB FMPER PRINT ERRORS DEF NAMO,I * * JSB READF READ FROM THE OUTPUT FILE DEF RTN17 DEF DCBO,I DEF RUBSH DEF PBUFF,I DEF .75 DEF PLNG RTN17 JSB FMPER PRINT ANY ERRORS DEF NAMO,I * * JSB POSNT BACKSPACE AGAIN DEF RTN18 DEF DCBO,I DEF RUBSH DEF M1 RTN18 JSB FMPER PRINT ERRORS DEF NAMO,I * LDA PLNG RAL CONVERT LENGTH TO CHARACTERS STA PLNG CLE,RAR AND BACK TO WORDS CMA,INA ADA T#WDS SUBTRACT FROM OUTPUT FILE SIZE LDB T#WDS+1 SEZ,RSS ADB M1 (DOUBLE INTEGER) DST T#WDS LDA T#REC ADJUST CURRENT LINE NUMBER ADA M1 STA T#REC * ISZ GET JMP GET,I * SKP * * NAME:INSRC * SUBROUTINE TO OPEN THE MERGE FILE. * CALLING SEQUENCE: * JSB INSRC * * JUMPS TO 'ENDER' IF ERROR OCCURS * (ERROR CODE IN A) * INSRC NOP LDA EXFLG STA EXSAV SAVE THE EXCHANGE FLAG CLA STA EXFLG JSB LCLOZ CLOSE THE LIST FILE IF OPEN LDA TTY STA LIST ALLOW LISTING IF INTERACTIVE * * LDA PASS1 IS THE SOURCE FILE OPEN? SZA,RSS JMP INS2 NO LDA FNAME YES CPA INPUT IS THE SOURCE FILE BEING MERGED? RSS MAYBE JMP INS2 NO LDA FNAME+1 CPA INPUT+1 RSS MAYBE JMP INS2 NO LDA FNAME+2 CPA INPUT+2 JMP CLOSS YES, CLOSE THE SOURCE FILE * INS2 LDA PLNG SSA,RSS JSB OUTPT OUTPUT PENDING LINE INS3 JSB OPENW OPEN MERGE FILE DEF DCBL DCB ADDRESS DEF RUBSH ERROR DEF FNAME FILE NAME DEF ZERO DEF FSECR SECURITY DEF FCART CART. REF. DEF .128 SSA JMP ENDER ERROR, PRINT MESSAGE LDA EXSAV STA EXFLG RESTORE THE EXCHANGE FLAG JMP INSRC,I * * CLOSS LDA T#REC SAVE THE CURRENT RECORD NO. LDB PLNG SSB,RSS INA ADD ONE FOR THE PENDING LINE CMA,INA STA COUNT * JSB ./B1 ROLL OVER THE SOURCE FILE, THEN CLOSE IT * LDA COUNT SZA,RSS JMP INS3 NULL INPUT FILE * JSB READ READ THE FIRST LINE RSS INSLP JSB TR WRITE A LINE, THEN READ THE NEXT ISZ COUNT BACK TO WHERE WE STARTED? JMP INSLP JMP INS2 YES * EXSAV NOP * SKP * * NAME:LCLOZ * SUBROUTINE TO WRITE AN END OF FILE ON THE * LIST DEVICE AND CLOSE IT. * LCLOZ NOP CLOSE THE LIST FILE LDA LNAME CPA LOG JMP LCLZ LISTING TO TERMINAL * JSB WRITF WRITE AN END OF FILE ON THE LIST DEVICE DEF RTN3 DEF DCBL DEF RUBSH DEF RUBSH DEF M1 RTN3 CPA M11 DON'T CARE IF FILE IS CLOSED JMP LCLZX JSB FMPER PRINT ANY OTHER ERRORS DEF LNAME * LCLZ JSB CLOZE CLOSE THE LIST FILE DEF DCBL DEF LNAME * LCLZX CLA STA LNAME JMP LCLOZ,I * SKP * * NAME:LOC * SUBROUTINE TO CALL 'LOCF' AND DETERMINE THE DISC LU * AND SIZE OF THE CURRENT OUTPUT FILE. ALSO PRINTS * 'WAITING FOR LU XX'. * * CALLING SEQUENCE: * LDA ERCOD * JSB LOC * * LOC NOP STA ERCOD SAVE MOST RECENT ERROR CODE JSB LOCF GET FILE LU AND SIZE DEF RTN26 DEF DCBO,I DEF RUBSH ERROR CODE DEF RUBSH RECORD NO. DEF RUBSH BLOCK DEF RUBSH OFFSET DEF WSIZE SIZE IN SECTORS DEF WLU DISC LU RTN26 JSB FMPER PRINT ANY ERRORS DEF NAMO,I * JSB NAME MOVE THE LU NO. TO THE MESSAGE DEF WLU DEF DLU * JSB NAME MOVE THE FILE NAME TO THE MESSAGE DEF NAMO,I DEF FILE * * JSB REIO PRINT 'NO ROOM FOR FILEXX ON LU YY' DEF *+5 DEF .2 DEF LOG DEF FBUF DEF .14 JMP LOC,I * FBUF ASC 6,NO ROOM FOR FILE ASC 5,XXXXXX ON DLU ASC 3,YYYYYY * .14 DEC 14 * SKP * * NAME:LST * SUBROUTINE TO LIST A BUFFER ON * THE CURRENT LIST FILE. * CALLING SEQUENCE: * JSB LST * DEF BUFFER * DEF COUNT * LST NOP LDB LST,I GET ADDRESS ISZ LST STB LSTB1 LDA LST,I GET COUNT ISZ LST LDA A,I STA LSTB2 WORD COUNT LDA LFLAG IOR LIST SSA JMP LST,I NO LISTING ALLOWED LDA LIST CPA .2 JMP WF FILE, DO NOT ADD SPACES * ISZ LSTB2 BUMP COUNT JSB DIRCT ADB M1 BACK UP ADDRESS STB LSTB1 LDB LSTB1,I SAVE WORD PRECEDING MESSAGE STB LSTB3 LDB SPSP REPLACE WITH 2 SPACES STB LSTB1,I SZA,RSS JMP IMS PRINT MESSAGE ON CONSOLE WF JSB WRITF PRINT MESSAGE DEF *+5 DEF DCBL DCB OF LIST DEVICE DEF RUBSH ERROR LSTB1 NOP BUFFER ADDRESS DEF LSTB2 COUNT JSB FMPER PRINT ANY ERRORS DEF LNAME LDA LIST CPA .2 JMP LST,I * RSTR LDB LSTB3 STB LSTB1,I RESTORE WORD PRECEDING MESSAGE JMP LST,I * LSTB2 NOP LSTB3 NOP * * LNAME BSS 3 LIST FILE NAME BSS 1 LSECR BSS 1 LCART BSS 1 LTYPE BSS 1 LSIZE BSS 1 BSS 2 * * * * IMS JSB REIO LIST ON TERMINAL DEF *+5 DEF .2 DEF LOG DEF LSTB1,I DEF LSTB2 JMP RSTR SKP * * NAME:LSTSB * SUBROUTINES TO LIST THE PENDING LINE * CALLING SEQUENCE: * JSB LSTSB * LSTSB NOP LDB PLNG SSB,INB JMP EOFPR BRS CONVERT TO WORD COUNT STB MX.CH JSB LST PERFORM LIST DEF PBUFF,I DEF MX.CH JMP LSTSB,I * EOFPR CCA STA RPCNT SET TO JUMP OUT OF REPEAT LOOP CLA STA CLNG STA CCCNT START OF COMMAND BUFFER LDA LIST IOR LFLAG SZA JMP NODE1 ONLY PRINT IF LISTING TO TERMINAL * JSB REIO PRINT 'EOF' DEF *+5 DEF .2 DEF LOG DEF EOF DEF .2 WORD COUNT JMP NODE1 * EOF ASC 2,EOF SKP * * NAME:MACH? * SUBROUTINE TO COMPARE THE PENDING LINE TO * THE MATCH BUFFER. * CALLING SEQUENCE: * JSB MACH? * >NO MATCH * >MATCH * MACH? NOP COMPARE PENDING LINE TO MATCH BUFFER CLA STA BWIND LDA MLNG LDB MBUFF JSB COMPR JMP MACH?,I NO MATCH ISZ MACH? JMP MACH?,I MATCH * MLNG NOP * SKP * * NAME: M.T * SUBROUTINE TO EXCHANGE MBUFF AND TBUFF * BY SWAPPING POINTERS * CALLING SEQUENCE: * JSB M.T * * M.T NOP SWAP TBUFF AND MATCH BUFFER LDA TCCNT SZA,RSS JMP M.T,I TBUFF EMPTY - DO NOT SWAP STA MLNG CLA STA TCCNT LDA MBUFF LDB TBUFF STA TBUFF STB MBUFF JMP M.T,I SKP * * NAME:MX.CH * SUBROUTINE TO RETURN NEXT MATCH CHARACTER . * CALLING SEQUENCE: * JSB MX.CH * >END OF BUFFER * >CHARACTER IN A * MX.CH NOP LDA MX.CN # CHARACTERS ALREADY READ CPA MX.LN # CHARACTERS IN BUFFER JMP MX.CH,I END OF VALID DATA ISZ MX.CN ISZ MX.CH BUMP TO NORMAL RETURN CLE,ERA CONVERT TO WORDS ADA MX.BF ADD BASE ADDRESS JSB CH FETCH CHARACTER FROM BUFFER JMP MX.CH,I SKP * * NAME:MVW * SUBROUTINE TO MOVE WORDS FROM ONE BUFFER * TO ANOTHER. * CALLING SEQUENCE: * JSB MVW * DEF FROM ADDRESS * DEF TO ADDRESS * DEC # OF WORDS * >'FROM ADDRESS' + N IN A-REG * 'TO ADDRESS' + N IN B-REG * MVW NOP CLA STA REMAN CLEAR REMAINDER LDB MVW,I ISZ MVW JSB DIRCT MAKE ADDRESS DIRECT LDA B AND COPY TO A LDB MVW,I ISZ MVW JSB DIRCT * JSB .MVW MOVE WORDS DEF MVW,I REMAN NOP ISZ MVW JMP MVW,I SKP * * NAME:NAME * SUBROUTINE TO MOVE A FILE NAME TO A BUFFER. * IF THE PARAMETER IS NUMERIC, THE MESSAGE * 'LU XX' IS MOVED. * * CALLING SEQUENCE: * JSB NAME * DEF NAMBF (MUST BE IN 'NAMR' PARSED FORMAT) * DEF BUFFER (3-WORD DESTINATION BUFFER) * * NAME NOP MOVE A FILE NAME DLD NAME,I DST NAMBF ISZ NAME ISZ NAME JSB MVW MOVE THE FILE NAME NAMBF NOP BUFFR NOP DEC 3 LDA A,I RAR,SLA JMP NAME,I ASCII FILE NAME, DONE * LDA BUFFR,I NUMERIC (LU) AND B77 STA NAMBF JSB KCVT CONVERT LU TO DECIMAL DEF *+2 DEF NAMBF LDB BUFFR ADB .2 STA B,I DLD LU MOVE ASCII PREFIX DST BUFFR,I JMP NAME,I DONE * SKP * NAME:NLSLU * SUBROUTINE TO SET UP A NEW LIST FILE * AND POSITION TO A GIVEN RECORD NUMBER. * THE FILE NAME 'L' IS TAKEN TO MEAN THE CURRENTLY * OPEN LIST FILE. * CALLING SEQUENCE: * JSB NLSLU * * LISTING IS CONTROLLED BY THE FOLLOWING FLAGS: * LCOMF: -1 IF COMMAND NORMALLY OUTPUTS A LISTING * 0 OTHERWISE * * LFLAG: <0 IF "<" COMMAND HAS BEEN ENTERED TO SUPPRESS LISTING * 0 OTHERWISE * * LIST : <0 IF NO LIST DEVICE IS AVAILABLE * =0 IF LISTING IS TO GO TO THE SESSION CONSOLE * =1 IF LISTING IS TO GO TO A DEVICE * =2 IF LISTING IS TO GO TO A FILE * * * NLSLU NOP JSB SC.CR GET FILE NAME DEF FNAME JMP NLSLU,I NO NAME ENTERED CPA "L." JMP L.OPN USE CURRENT OPEN LIST FILE * LDA FTYPE CPA .1 JMP ER006 WRONG FILE TYPE CPA .2 JMP ER006 WRONG FILE TYPE * JSB LCLOZ CLOSE THE PREVIOUS LIST FILE * JSB MVW SAVE LIST FILE NAME DEF FNAME DEF LNAME DEC 10 * JSB OPENW OPEN THE NEW LIST FILE DEF DCBL DEF RUBSH ERROR CODE DEF LNAME NAME DEF ZERO DEF LSECR DEF LCART DEF .128 CPA M6 JMP CRETL CREATE A LIST FILE SSA JMP NOLST STA LTYPE * NLSEX LDB LTYPE SZB TYPE4 CLB,INB INB DEVICE=1, FILE=2 STB LIST CLB STB LFLAG CCB LDA EXFLG SZA,RSS STB LCOMF ALLOW LISTING * LDA LIST CPA .2 RSS ALLOW RECORD NUMBER IF LISTING TO A FILE JMP NLSLU,I JSB NUMIN GET THE ABSOLUTE RECORD NUMBER SZA,RSS JMP NLSLU,I NO POSITIONING DESIRED STA REC * JSB POSNT POSITION THE LIST FILE DEF RTN20 DEF DCBL DEF RUBSH DEF REC DEF REC RTN20 SSA CPA M12 IF PAST EOF, IGNORE THE ERROR JMP NLSLU,I JMP NOLST PRINT ANY OTHER ERROR JMP NLSLU,I * * CRETL LDA LSIZE SZA,RSS LDA .24 STA LSIZE LDA LTYPE SZA,RSS LDA .4 DEFAULT TO TYPE 4 STA LTYPE JSB CREAT CREATE THE LIST FILE DEF RTN11 DEF DCBL DEF RUBSH DEF LNAME DEF LSIZE DEF LTYPE DEF LSECR DEF LCART RTN11 SSA,RSS JMP TYPE4 LIST FILE AVAILABLE NOLST JSB FMPER PRINT ERROR DEF LNAME JSB LCLOZ CLOSE THE LIST DCB JMP NODE1 * "L." ASC 1,L REC NOP * L.OPN LDA LNAME SZA JMP NLSEX JMP ER000 NO LIST FILE OPEN, ERROR * SKP * * NAME:NUMIN * SUBROUTINE TO PARSE A NUMERIC PARAMETER FROM * THE COMMAND BUFFER. PRINTS 'ER000' IF THE PARAMETER * IS ASCII OR NEGATIVE. * CALLING SEQUENCE: * JSB NUMIN * > NUMBER IN A * NUMIN NOP JSB SC.CR PARSE INPUT DEF BUF10 JMP NUMIN,I DEFAULT LDB BUF10+3 SSA,RSS RBR,SLB JMP ER000 NEGATIVE OR ALPHA IS INVALID JMP NUMIN,I SKP * * NAME:NXCHR * SUBROUTINE TO FETCH NEXT COMMAND CHARACTER. * SKIPS ALL BLANKS. * CALLING SEQUENCE: * JSB NXCHR * >COMMA OR END OF BUFFER RETURN HERE * >ANY OTHER CHARACTER IN A * NXCHR NOP JSB ECH FETCH NEXT COMMAND CHAR. JMP NXCHR,I NO MORE CHARS, RETURN CPA COMMA JMP NXCHR,I COMMA, EXIT ISZ NXCHR BUMP RETURN ADDRESS JMP NXCHR,I * SKP * NAME:OPENW * SUBROUTINE TO OPEN A FILE OR LU WITH WAIT. * IF THE FILE IS OPEN OR THE LU IS LOCKED TO * ANOTHER PROGRAM, THE EDITOR PRINTS * THE MESSAGE 'WAITING FOR XXXXXX', AND THEN * RETRIES THE OPEN REQUEST FOREVER AT 6 SECOND * INTERVALS. RETRIES MAY BE STOPPED BY AN OPERATOR BREAK. * * * CALLING SEQUENCE: * JSB OPENW * DEF DCB * DEF ERROR * DEF NAME * DEF OPTION * DEF SECR * DEF CR * DEF DCB SIZE * >ERROR CODE IN A * * OPENW NOP OPEN WITH WAIT CLA STA ERCOD JSB MVW MOVE THE PARAMETERS TO THE CALL DEF OPENW,I DEF OPEND .7 DEC 7 LDA OPENW ADA .7 ADJUST THE RETURN ADDRESS STA OPENW * * OPNLP JSB OPENF OPEN THE FILE OR LU DEF *+8 OPEND NOP DCB OPENE NOP ERROR CODE OPENN NOP NAME NOP OPTION NOP SECR NOP CARTRIDGE NOP DCB SIZE CPA .1 JMP BADTY WRONG FILE TYPE CPA .2 JMP BADTY WRONG FILE TYPE SSA,RSS JMP OPENW,I SUCCESS! * * CPA M8 RSS FILE OPEN CPA M36 RSS LU LOCKED JMP OPENW,I FAILURE * * * CPA ERCOD JMP WAITO MESSAGE ALREADY PRINTED * STA ERCOD JSB NAME MOVE FILE NAME TO MESSAGE DEF OPENN,I DEF WBUF+9 * JSB REIO PRINT 'WAITING FOR XXXXXX' DEF *+5 DEF .2 DEF LOG DEF WBUF DEF .12 * * WAITO JSB WAIT WAIT 6 SECONDS JMP OPNLP TRY AGAIN LDA OPENE,I NO MORE RETRIES, BREAK FLAG SET JMP OPENW,I FAILURE * * BADTY JSB CLOZE CLOSE THE FILE DEF OPEND,I DEF OPENN,I JSB ERROR 'WRONG FILE TYPE' DEF MS006 DEC 12 LDA SIGN JMP OPENW,I * WBUF ASC 12,XXXXX WAITING FOR XXXXXX M8 DEC -8 M36 DEC -36 M100 DEC -100 SIGN OCT 100000 * * SKP * * NAME:OUTPT * SUBROUTINE TO EXCHANGE IN THE PENDING LINE * AND OUTPUT IT TO THE FILE. * CALLING SEQUENCE: * JSB OUTPT * OUTPT NOP LDA PLNG IF EOF-NO PATTERNS SSA,RSS JSB EXCH EXCHANGE IF ENABLED JSB WRITE CALL OUTPUT ROUTINE JMP OUTPT,I SKP * * NAME:OUTCR * SUBROUTINE TO STORE CHARACTER IN LOWER BYTE * OF A-REGISTER INTO TBUFF. BLANKS LOWER * BYTE OF WORD IN TBUFF IF A-REGISTER IS TO * BE STORED IN HIGH BYTE. * NO ACTION IF TBUFF IS FULL. * CALLING SEQUENCE: * LDA CHARACTER * JSB OUTCR * OUTCR NOP LDB TCCNT # CHARACTERS ALREADY IN BUFFER CPB .150 MAX ALLOWED IN BUFFER JMP OUTCR,I BUFFER ALREADY FULL CLE,ERB CONVERT TO WORDS ADB TBUFF ADD BASE ADDRESS SEZ,RSS MOVE CHARACTER TO PROPER BYTE ALF,SLA,ALF FOR INSERTION XOR B,I IF LOW BYTE, OR-TIE HIGH BYTE FROM BUFFER XOR SPACE FORCE LOWER BYTE TO SPACE IF NOT PROVIDED STA B,I MOVE CREATED WORD TO BUFFER ISZ TCCNT BUMP COUNTER JMP OUTCR,I * .150 DEC 150 SKP * * NAME:PCH * SUBROUTINE TO FETCH NEXT PENDING LINE CHARACTER * CALLING SEQUENCE: * JSB PCH * >END OF BUFFER * >CHARACTER IN A * PCH NOP ENTER WITH CHARACTER COUNT IN LDA PCCNT PCCNT AND SOURCE BUFFER START CPA PLNG ADDRESS IN PBUFF. JMP PCH,I ISZ PCCNT IF AT END OF SOURCE RECORD, ISZ PCH EXIT TO P+1. CLE,ERA ADA PBUFF IF NOT AT END OF SOURCE RECORD, JSB CH FETCH CHARACTER FROM BUFFER JMP PCH,I * SKP * * NAME:POSTI * THIS ROUTINE POSTS THE INPUT DCB TO MAKE * IT AVAILABLE FOR A BACK-UP STACK. * THE STACK POINTERS ARE INITIALIZED. * CALLING SEQUENCE: * JSB POSTI * * POSTI NOP POST THE INPUT BUFFER LDA SLNG SZA JMP POSTI,I ALREADY POSTED * JSB POST FREE UP THE BUFFER DEF *+2 DEF DCBI,I JSB FMPER PRINT ANY ERRORS DEF NAMI,I * LDA DCBI ADA .16 STA SPTR POINTER TO BUFFER * LDA DCBSZ CMA,INA STA SCNT NEG. NO. OF WORDS AVAILABLE JMP POSTI,I * SCNT NOP * SKP * * NAME:PUSH * THIS ROUTINE PUSHES THE PENDING LINE ONTO * THE BACK-UP STACK IN THE INPUT DCB. * * THE THE RECORD LENGTH IN CHARACTERS IS STORED * IN THE WORD FOLLOWING THE DATA. * CALLING SEQUENCE: * JSB PUSH * >STACK OVERFLOW * >DATA ACCEPTED * PUSH NOP MOVE A RECORD TO THE STACK LDA PLNG SSA JMP POUT END OF FILE, SKIP IT INA ARS CONVERT TO WORD COUNT STA CNT ADA SCNT CHECK FOR ROOM ON STACK SSA,RSS JMP PUSH,I OVERFLOW * INA LENGTH WORD STA SCNT ISZ SLNG BUMP STACK RECORD COUNT JSB MVW DEF PBUFF,I DEF SPTR,I CNT NOP LDA PLNG STA B,I TOP OF STACK GETS RECORD LENGTH INB STB SPTR NEW STACK POINTER VALUE * POUT ISZ PUSH JMP PUSH,I * SKP * * NAME:READ * SUBROUTINE TO READ A RECORD FROM THE * CURRENT INPUT FILE AND STORE IT IN * THE PENDING LINE BUFFER. THE RECORD IS POPPED OFF THE STACK * IF THE BACK-UP STACK IS NOT EMPTY. * CALLING SEQUENCE: * JSB READ * >PLNG IN A (-1 IF END OF FILE) * READ NOP CLB STB PCCNT LDA SLNG SZA JMP POP READ IT FROM THE STACK * JSB READF READ FROM THE INPUT FILE DEF *+6 DEF DCBI,I READ DEF RUBSH SOURCE DEF PBUFF,I RECORD DEF .75 DEF PLNG * CPA M12 JMP OKEOF END OF FILE JSB FMPER PRINT ANY OTHER ERRORS DEF NAMI,I OKEOF CCB SSA STB PLNG SET LINE LENGTH TO -1 LDA PLNG SSA JMP READ,I END OF FILE ALR CONVERT COUNT TO CHARS STA PLNG RDOUT ISZ LINES BUMP LINE COUNT JMP READ,I * * POP ADA M1 STA SLNG ONE LESS RECORD ON STACK CCB ADB SPTR LDA B,I SIZE OF RECORD STA PLNG INA ARS CONVERT TO WORD COUNT STA RDCNT CMA,INA ADB A STB SPTR NEW STACK POINTER ADA M1 ADA SCNT STA SCNT UPDATE NO. OF WORDS AVAILABLE ON STACK * JSB MVW SPTR NOP DEF PBUFF,I RDCNT NOP JMP RDOUT * M12 DEC -12 * SKP * * NAME:RDM * THIS ROUTINE READS A RECORD FROM THE MERGE FILE * INTO PBUFF. JUMPS TO IF AN * ERROR OCCURS OF IF END OF FILE IS READ. * CALLING SEQUENCE: * JSB RDM * >LINE LENGTH IN A * RDM NOP READ MERGE FILE JSB READF READ MERGE FILE DEF *+6 DEF DCBL DEF RUBSH DEF PBUFF,I DEF .75 DEF PLNG JSB FMPER PRINT ANY ERRORS DEF FNAME IOR PLNG SSA JMP ENDM ERROR OR END OF FILE CLB STB PCCNT LDA PLNG ALS STA PLNG MULTIPLY BY TWO FOR CHARACTERS JMP RDM,I * SKP * * NAME:READE * THIS ROUTINE READS A LINE FROM THE INPUT FILE * AND JUMPS TO IF END OF FILE IS READ. * CALLING SEQUENCE: * JSB READE * >PLNG IN A * * READE NOP READ AND CHECK FOR END OF FILE JSB READ READ NEXT RECORD SSA JMP DISPL END OF FILE - PRINT MESSAGE JMP READE,I * SKP * * NAME:RWNDI * SUBROUTINE TO REWIND THE CURRENT INPUT FILE * AND RESET THE CURRENT LINE COUNTER TO ZERO. * CALLING SEQUENCE: * JSB RWNDI * RWNDI NOP * JSB RWNDF ! REWIND DEF *+2 ! THE INPUT DEF DCBI,I ! FILE * JSB FMPER PRINT ERRORS IF ANY DEF NAMI,I CLA RESET THE LINE COUNTER STA LINES STA SLNG CLEAR THE STACK JMP RWNDI,I SKP * * NAME:RWNDO * SUBROUTINE TO REWIND THE CURRENT * OUTPUT FILE. * CALLING SEQUENCE: * JSB RWNDO * RWNDO NOP * JSB RWNDF ! DEF *+2 ! DEF DCBO,I ! * JSB FMPER PRINT ERRORS IF ANY DEF NAMO,I * JSB WEOF WRITE AN END OF FILE * CLA RESET DESTINATION FILE RECORD COUNTERS STA T#REC STA T#WDS STA T#WDS+1 JMP RWNDO,I NONE SKP * * NAME:SC.CR * SUBROUTINE TO PARSE A FILE NAME . THE RETURNED * BUFFER IS TEN WORDS LONG: * WORDS 1-3 : FILE NAME (OR LU IN WORD 1) * WORD 4 : PARAMETER TYPES (SEE SUBROUTINE) * WORD 5 : SECURITY CODE * WORD 6 : CARTRIDGE REFERENCE * WORD 7 : FILE TYPE * WORD 8 : FILE SIZE * WORD 9 : RESERVED * WORD 10 : RESERVED * * CALLING SEQUENCE: * JSB SC.CR * DEF BUFFER * >NULL OR ZERO * >WORD 1 IN A * * SC.CR NOP LDA SC.CR,I ISZ SC.CR STA PRSBF ISZ ECCNT ADJUST CHAR COUNT * JSB NAMR PARSE THE INPUT DEF *+5 PRSBF NOP DEF EBUFF,I DEF ELNG DEF ECCNT * CCB ADB ECCNT RESET THE CHAR COUNT STB ECCNT LDA PRSBF,I SZA ISZ SC.CR BUMP UNLESS DEFAULTED JMP SC.CR,I * SKP * * * NAME:SWPET * SUBROUTINE TO EXCHANGE TBUFF AND EBUFF BY * SWAPPING BUFFER POINTERS. * CALLING SEQUENCE: * JSB SWPET * SWPET NOP LDA TBUFF SWAP LDB EBUFF EBUFF STA EBUFF AND STB TBUFF TBUFF LDA TCCNT STORE OUTPUT CHARACTER STA ELNG LENGTH IN COMMAND LENGTH CLB RESET COMMAND STB ECCNT AND OUTPUT STB TCCNT CHARACTER POINTERS JMP SWPET,I * SKP * * NAME:TAB * SUBROUTINE TO SCAN TEXT LINE IN EBUFF * MOVING IT TO TBUFF * REPLACING TAB CHARACTERS WITH THE CORRECT NUMBER * OF TAB FILLER CHARACTERS (USUALLY SPACES) * CALLING SEQUENCE: * JSB TAB * TAB NOP CLA RESET OUTPUT STA TCCNT CHARACTER COUNTER AND STA SWPET NON-CONTROL CHARACTER COUNTER LDA TABUF RESET STA TBPNT TAB POINTER TAB1 JSB ECH GET NEXT COMMAND CHARACTER JMP TAB,I END OF COMMAND CPA TABCR TAB CHARACTER ? JMP TBFND YES, GO TO TAB FOUND LDB A IS CHARACTER CMB CONTROL ADB SPACE CHARACTER SSB IF YES DO NOT INCREMENT ISZ SWPET NON-CONTROL CHARACTER COUNTER JSB OUTCR NO, OUTPUT CHARACTER JMP TAB1 TBFND CCB SET FILL COUNTER STB TR TBFLP LDB TBPNT,I TAB POINTER CMB,INB,SZB,RSS JMP TABIT END OF LIST, OUTPUT SINGLE FILL CHAR INB ISZ TBPNT BUMP TAB POINTER ADDRESS ADB SWPET PAST SSB,RSS TAB? JMP TBFLP YES, GET NEXT TAB STB TR STORE FILL COUNTER TABIT LDA TBFIL OUTPUT FILL CHAR JSB OUTCR ISZ SWPET BUMP NON-CONTROL CHAR. CNTR. ISZ TR LAST FILL? JMP TABIT NO, CONTINUE FILLING JMP TAB1 GET NEXT CHARACTER SKP * * NAME:TR * SUBROUTINE TO CONTROL PENDING LINE MOVES TO THE * DESTINATION FILE OPTIONALLY LISTING LINE DURING * MOVE. FETCHES NEXT LINE AFTER MOVE. ALSO * CHECKS FOR OPERATOR INTERRUPTS. * CALLING SEQUENCE: * JSB TR * >LENGTH OF NEW LINE IN A * TR NOP LDA PLNG IF AT SSA EOF, JMP DISPL PRINT MESSAGE JSB BRK? TEST BREAK FLAG DEF DISPL BREAK FLAG SET JSB EXCH EXCHANGE IF ENABLED LDB LCOMF LIST CURRENT SZB RECORD? JSB LSTSB YES, PERFORM LIST LDB TRFLG TRANSFER RECORD TO SZB DESTINATION FILE? JSB WRITE YES-OUTPUT RECORD JSB FMP? JUMP IF ERROR DEF DISPL JSB READE READ NEXT INPUT JMP TR,I SKP * NAME:RDCOM * SUBROUTINE TO PRINT PROMPT CHARACTER * RING BELL, INPUT COMMAND, AND RESET * CHARACTER COUNTERS. * CALLING SEQUENCE: * JSB RDCOM * >A=ZERO * RDCOM NOP STB PRMLN ADDRESS OF PROMPT LENGTH INB STB PRMPT AND PROMPT * JSB BRK? TEST THE BREAK FLAG DEF *+1 LDA BRKFL IOR FMP SZA JMP RDCM1 BREAK HAS OCCURRED ISZ RPCNT JMP ZCNT SKIP READ, RESET POINTER RDCM1 LDB TTY SZB INTERACTIVE INPUT DEVICE? JMP NOTY NO STB BRKFL CLEAR THE BREAK FLAG STB FMP CLEAR THE FMP ERROR ACCUMULATOR * JSB .OPSY L-SERIES OP SYSTEM? CPA M31 JMP ZEIO YES CPA M29 JMP ZEIO YES, L/20 * JSB REIO WRITE THE PROMPT DEF *+5 DEF .2 DEF LOG DEF PRMPT,I DEF PRMLN,I * JSB REIO READ THE RESPONSE DEF *+5 DEF .1 DEF ELOG LOG LU, ECHO BIT SET DEF CBUF0 DEF M150 JMP RDEX PROCESS COMMAND * * ZEIO JSB REIO WRITE/READ FROM TERMINAL DEF RTN14 DEF .1 DEF ZLOG LOG LU, Z-BIT & E-BIT SET DEF CBUF0 DEF M150 PRMPT NOP PRMLN NOP RTN14 JMP RDEX * NOTY SZA JMP ./AB BREAK, ABORT EDIT * JSB READF READ A RECORD FROM COMMAND INPUT DEVICE DEF *+6 DEF DCBE DEF RUBSH CBUFF DEF CBUF0 DEF .75 WORD COUNT DEF CLNG ACTUAL TRANSMISSION JSB FMPER PRINT ANY ERRORS DEF ENAME LDB CLNG SSB CLB,RSS IF EOF, SET TO ZERO BLS CONVERT TO CHARACTER COUNT RDEX STB CLNG CCA STA RPCNT DEFAULT REPEAT COUNT ZCNT CLA STA CCCNT CLEAR COMMAND CHAR COUNTER STA LFLAG JMP RDCOM,I * * M29 DEC -29 M31 DEC -31 * SKP * * NAME:TTYIP * THIS ROUTINE EXTRACTS A COMMAND FROM CBUFF * AND MOVES IT TO EBUFF. IF THE REPEAT COUNT * IS EXCEDED, A NEW COMMAND IS READ INTO CBUFF. * CALLING SEQUENCE: * JSB TTYIP * DEF PROMPT (IGNORED IF NON-INTERACTIVE * OR IF COMMAND BUFFER STILL VALID) * * TTYIP NOP FETCH A COMMAND LDB TTYIP,I ISZ TTYIP LDA CCCNT CPA CLNG IF LINE IS EXHAUSTED JSB RDCOM READ NEXT STA TRUNC SAVE CURRENT CHARACTER COUNT CLA STA PCCNT RESET PENDING LINE POINTER STA TCCNT AND OUTPUT BUFFER POINTER JSB CCH FETCH A COMMAND CHARACTER JMP *+3 END OF COMMAND JSB OUTCR COPY TO TBUFF JMP *-3 JSB SWPET SWAP TBUFF AND EBUFF JMP TTYIP,I * SKP * * NAME:WAIT * SUBROUTINE TO WAIT 6 SECONDS AND CHECK THE BREAK FLAG. * * CALLING SEQUENCE: * JSB WAIT * >NORMAL RETURN * >BREAK FLAG SET * WAIT NOP WAIT 6 SECONDS JSB BRK? CHECK THE BREAK FLAG DEF RTN23 RETURN +2 * JSB EXEC TIME SUSPEND THE EDITOR DEF RTN23 DEF TIME CODE 12 DEF ZERO NAME DEF .2 CODE 2=SECONDS DEF ZERO MULTIPLE DEF M6 6 SECONDS * RTN23 ISZ WAIT BREAK, OR ABORT RETURN FROM EXEC 12 JMP WAIT,I * TIME DEF 12,I TIME SUSPEND, NO ABORT * SKP * * NAME:WEOF * THIS ROUTINE WRITES AN END OF FILE TO * THE OUTPUT FILE AND THEN BACKSPACES OVER IT. * IT IS VERY IMPORTANT TO WRITE AN END OF FILE * WHENEVER THE OUTPUT FILE IS RE-POSITIONED BECAUSE * IT IS NORMALLY IN UPDATE MODE. IF THE EOF IS * NOT WRITTEN, THEN AN FMP -5 ERROR MAY BE REPORTED. * CALLING SEQUENCE: * JSB WEOF * * WEOF NOP WRITE END OF FILE JSB WRITF WRITE END OF FILE DEF RTN13 DEF DCBO,I DEF RUBSH DEF RUBSH (BUFFER) DEF M1 RTN13 JSB FMPER DEF NAMO,I * JSB POSNT BACKSPACE OVER 'EOF' DEF RTN19 DEF DCBO,I DEF RUBSH DEF M1 RTN19 CPA M3 JMP WEOF,I 'BACKSPACE ILLEGAL', IGNORE IT JSB FMPER PRINT ANY OTHER ERRORS DEF NAMO,I JMP WEOF,I * SKP * * NAME:WRITE * SUBROUTINE TO WRITE THE PENDING LINE * AND TRACK THE NUMBER OF RECORDS AND WORDS IN THE * DESTINATION FILE. * CALLING SEQUENCE: * JSB WRITE * WRITE NOP LDA PLNG FETCH NUMBER OF CHARACTERS IN LINE SSA JMP WREOF WRITE END OF FILE STA ERCOD SET FLAG POSITIVE INA CLE,ARS CONVERT TO WORDS STA TEMP ADA T#WDS UPDATE # OF WORDS IN DEST CHAIN/FILE SEZ ISZ T#WDS+1 STA T#WDS ISZ T#REC BUMP RECORD COUNT * WRLP JSB WRITF WRITE THE RECORD DEF RTN15 DEF DCBO,I DEF WERR DEF PBUFF,I DEF TEMP RTN15 CPA M33 JMP WFILE NO FILE SPACE FOR EXTENT CPA M14 JMP WDIRC NO DIRECTORY SPACE FOR EXTENT JSB FMPER PRINT ANY ERRORS DEF NAMO,I JMP WRITE,I * TEMP NOP M33 DEC -33 M14 DEC -14 ERCOD NOP * WLU NOP THERE MUST BE A ZERO AT 'WLU+3' WERR NOP WSIZE NOP WZERO OCT 0 * WFILE CPA ERCOD JMP WAITW ERROR MESSAGE ALREADY PRINTED * JSB LOC GET THE DISC LU AND #OF BLOCKS REQUIRED * LDA WSIZE ARS DIVIDE SECTORS BY TWO STA WSIZE TO GET BLOCKS * JSB CNUMD CONVERT BLOCKS TO ASCII DEF *+3 DEF WSIZE DEF WFMSG+2 * JSB REIO PRINT 'NEED XXXXX BLOCK EXTENT' DEF *+5 DEF .2 DEF LOG DEF WFMSG DEF .12 * WAITW JSB WAIT WAIT 6 SECONDS JMP WRLP TRY AGAIN * LDA WERR BREAK FLAG SET, NO MORE RETRIES JSB FMPER PRINT FMP ERROR CODE DEF NAMO,I * * JSB REIO PRINT 'ENTER "-77777B,FILEXX" COMMAND' DEF *+5 DEF .2 DEF LOG DEF ENTER DEF .15 JMP WRITE,I FAILURE * * WDIRC CPA ERCOD JMP WAITW MESSAGE ALREADY PRINTED, WAIT 6 SECONDS * JSB LOC GET THE DISC LU * JSB REIO PRINT 'NEED DIRECTORY SPACE' DEF *+5 DEF .2 DEF LOG DEF WDMSG DEF .10 JMP WAITW WAIT 6 SECONDS AND TRY AGAIN * * WREOF JSB WEOF WRITE THE END OF FILE JMP WRITE,I * * * * WFMSG ASC 12,NEEDXXXXXX BLOCK EXTENT WDMSG ASC 10,NEED DIRECTORY SPACE ENTER ASC 15,ENTER "-77777B,FILEXX" COMMAND * SKP * * NAME:YCH * SUBROUTINE TO FETCH THE NEXT CHARACTER * FROM THE REPLACEMENT STRING. * CALLING SEQUENCE: * JSB YCH * >END OF BUFFER * >CHARACTER IN A * YCH NOP LDA YCCNT # CHARACTERS ALREADY READ CPA YLNG # CHARACTERS IN BUFFER JMP YCH,I END OF VALID DATA ISZ YCCNT ISZ YCH BUMP TO NORMAL RETURN ADA YOFFS BUMP TO CHARACTER WANTED CLE,ERA CONVERT TO WORDS ADA XYBUF ADD BASE ADDRESS JSB CH FETCH CHARACTER FROM BUFFER JMP YCH,I RETURN SKP * * BUFFERS * CBUF0 BSS 75 DCBE BSS 144 DCBL BSS 144 DCBIH BSS 16 DCBSH BSS 16 * * EBUF0 EQU *+3 BSS 78 * MBUF0 EQU *+3 BSS 78 * PBUF0 EQU *+3 BSS 78 * TBUF0 EQU *+3 BSS 78 * XYBF0 EQU *+3 BSS 78 * SIZE EQU * END EDITL