.TITLE RNCMD .IDENT /BL3.0/ ; ; ; Dec assumes no responsibility for the use or reliability of this ; software. ; ; ; Original AUTHOR: L. WADE 1-JUN-72 ; ; MODIFIED BY: ; ; E. POLLACK U. OF W. 19-DEC-73 ; ; D. N. CUTLER 27-JUL-75 ; ; RUNOFF COMMANDS ; ; ; CHANGES BY J. CLEMENT AUGUST 1982 ; ADD EXTRA FLAGS (SPACE,ACCEPT...) ; MAKE ALL ENABLE/DISABLE COMMANDS THE SAME LOGIC ; Lots of new commands added ; ; ; ALL COMMAND ROUTINES ARE ENTERED WITH: ; ; R4=ADDRESS OF NUMBER CONVERSION ROUTINE. ; .psect $TEMP gbl,d,rw,ovr ADDR: .BLKW 1 COUNT: .BLKW 1 STAT: .BLKW 1 .PSECT $CODE LCL,I,RO,CON ; ; PERIOD commands ; PERSP:: BISB #SW.DIS,$PERSW ; ENABLE TWO SPACES AFTER PUNCTUATION MOV #CH.PER,R5 ; Bits to set/clear PERSET: CALL GETLIT ; Get literal BCS 30$ ; None ? TSTEQ R1,30$ ; No characters ? 20$: MOVB (R2)+,R0 ; Get character BISB R5,CHTABL(R0) ; Set the bit SOB R1,20$ ; Continue till done 30$: RETURN ; NPERS:: CLRB $PERSW ; DISABLE TWO SPACES AFTER PUNCTUATION MOV #CH.PER,R5 ; Bits to set/clear PERCLR: CALL GETLIT ; Get literal BCS 30$ ; None ? TSTEQ R1,30$ ; No characters ? 20$: MOVB (R2)+,R0 ; Get character BICB R5,CHTABL(R0) ; Set the bit SOB R1,20$ ; Continue till done 30$: RETURN ; ; ; ENABLE/DISABLE CHANGE BAR COMMADS (ALSO ON AND OFF) ; ENCBR:: BICB #SW.DIS,$CBRSW ; ENABLE BAR CALL (R4) ; Get first indent MOV #0,R3 ; Default CMP R3,#10. ; Test size BHI 20$ ; Too big ? MOV R3,EBSIZ1 ; First indent CALL (R4) ; Second indent MOV #CBNSP,R3 ; Default second offset CMP R3,#10. ; Test size BHI 20$ ; Too big ? MOV R3,EBSIZ2 RETURN 20$: MOV #4.,R0 ; Param too big or negative JMP ILCMA DSCBR:: TSTNEB $CBRSW,10$ ; Already disabled ? BISB #SW.DIS,$CBRSW ; DISABLE BAR 10$: RETURN ENBAR:: BISB #100,$CBRSW ; BAR OFF RETURN BGBAR:: BICB #100,$CBRSW ; BAR OFF RETURN ; ; ENABLE CONTINUE ; ENCONT::BICB #SW.DIS,$CONT ; Enable continue RETURN DSCONT::BISB #SW.DIS,$CONT ; Disable continue RETURN ; ; KEEP LINES command ; KEEP TABS command ; KEEPL:: BISB #SW.DIS,$KEEPL ; Enable keep lines RETURN NKEEPL::BICB #SW.DIS,$KEEPL ; Disable keep lines RETURN KEEPT:: BISB #SW.DIS,$KEEPT ; Enable keep tabs RETURN NKEEPT::BICB #SW.DIS,$KEEPT ; Disable keep tabs RETURN ; ; AUTOPARAGRAPH commands ; AUTOP:: MOVB #-1,$AUTSW ; SET AUTOPARAGRAPH MODE RETURN ; NAUTO:: CLRB $AUTSW ; CLEAR AUTOPARAGRAPH MODE RETURN ; AUTTB:: MOVB #1,$AUTSW ; Set autotable mode RETURN ; ; AUTOHYPHENATE commands ; AUHYP:: BICB #SW.DIS,$AUHYP ; Set autohyphenate enabled CALL RCNR ; Get initial char count JMP 10$ ; None ? MOVB R3,HYPSV ; Char saved ? 10$: CALL RCNR ; Get initial char count JMP 20$ ; None ? MOVB R3,HYPLO ; Initial char count 20$: CALL RCNR ; Get Final char count JMP 30$ ; None ? MOVB R3,HYPHI ; Final char count 30$: CALL RCNR ; Get Option JMP 40$ ; None ? MOVB R3,HYPOP ; Save hyphenation option 40$: MOV HYPLO,R0 ; Get lo value ADD HYPHI,R0 ; Add on final char count NEG R0 ; Make it the negative MOV R0,HYPSZ ; Save as size MOV #CH.PNC,R5 ; Set up punctuations JMP PERSET NAUHYP:: BISB #SW.DIS,$AUHYP ; Set autohyphenate disabled MOV #CH.PNC,R5 ; Set up punctuations JMP PERCLR ; ; ELLIPSES commands ; ELIPS:: BISB #SW.DIS,$ELIPS ; Set ellipses flag RETURN NELIP:: CLRB $ELIPS ; Clear ellipses flag RETURN ; ; TAB RIGHT command ; TAB LEFT command ; TABRI:: BISB #SW.DIS,$TABLF ; Set up for right justify tabs RETURN TABLF:: CLRB $TABLF ; Left justify tabs RETURN ; ; ENABLE/DISABLE commands ; ; 0=ENABLED NONZERO=DISABLED ; ENESC:: BICB #SW.DIS,$ESCSW ; ENABLE ESCAPE SEQ. RETURN DSESC:: BISB #SW.DIS,$ESCSW ; DISABLE ESCAPE SEQ. RETURN ENSUB:: BICB #SW.DIS,$SUBSW ; enable substitution RETURN DSSUB:: BISB #SW.DIS,$SUBSW ; disable substitution RETURN ENTAB:: BICB #SW.DIS,$TABSW ; Enable tabs RETURN DSTAB:: BISB #SW.DIS,$TABSW ; Disable tabs RETURN ENUNL:: BICB #SW.DIS,$UNLSW ; ENABLE UNDERLINE SEQ. RETURN DSUNL:: BISB #SW.DIS,$UNLSW ; DISABLE UNDERLININE RETURN ENOVR:: BICB #SW.DIS,$OVRSW ; ENABLE OVERSTRIKING RETURN DSOVR:: BISB #SW.DIS,$OVRSW ; DISBLE OVERSTRIKING RETURN ENHYP:: BICB #SW.DIS,$HYPSW ; ENABLE HYPHENATION RETURN DSHYP:: BISB #SW.DIS,$HYPSW ; DISABLE HYPHENATION RETURN ENINX:: BICB #SW.DIS,$INXSW ; ENABLE INDEXING RETURN DSINX:: BISB #SW.DIS,$INXSW ; DISABLE INDEXING RETURN ; ; INDENT command ; INDENT::TSTEQB $CENSW,10$ ; No Centering ? JMP ERRCON ; Conflicting command 10$: CALL (R4) ; READ SIGNED DECIMAL NUMBER MOV PARIND,R3 ; NONE. USE CURRENT VALUE INDCK: MOV LMARG,R0 ; Compare if legit NEG R0 ; TSTNEB $RIGSW,10$ ; Right margin ? CMP R3,R0 BLT ERRLT ; Yes! 10$: SUB R3,R0 ; Is it less than left margin ADD RMARG,R0 ; Space available CMP R0,#MINLN ; Now compare with line minimum BLT ERRGT ; Indent too big ? CMP R0,#255. ; Compare with max char per line BHI ERRLT ; Indent too small MOV R3,INDCT ; Save indentation RETURN ; ; TOP MARGIN command ; SETTM:: MOV TMARG,R3 ; GET CURRENT TOP MARGIN CALL (R4) ; GET RELATIVE ARGUMENT JMP 10$ ; Take default CALL CVSP ; Convert to half spacing BR 20$ ; Now check it 10$: MOV PTMRG,R3 20$: ADD #MINPG,R3 ; MINPG lines minimum on page CMP R3,PNLPG ; MUST BE LESS THAN PAGE LENGTH? BGE ERRGT ; IF GE NO SUB #MINPG,R3 ; TAKE DEMANDED LINE OUT MOV R3,TMARG ; OK SAVE AS TOP MARGIN RETURN ; ; ; LEFT MARGIN command ; SETLM:: MOV LMARG,R3 ; GET CURRENT LEFT MARGIN CALL (R4) ; GET RELATIVE ARGUMENT MOV PLMRG,R3 ; IF NONE, INITIALIZE ADD #MINLN,R3 ; Add on minimum line length CMP R3,RMARG ; MUST BE LESS THAN RIGHT MARGIN? BGE ERRGT ; IF GE NO SUB #MINLN,R3 ; Restore MOV R3,LMARG ; OK SAVE AS LEFT MARGIN RETURN ; ; ; RIGHT MARGIN command ; SETRM:: MOV RMARG,R3 ; GET CURRENT RIGHT MARGIN CALL (R4) ; GET RELATIVE ARGUMENT MOV PRMRG,R3 ; IF NONE, INITIALIZE SUB #MINLN,R3 ; Subtract min line length CMP R3,LMARG ; MUST BE RIGHT OF LEFT MARGIN BLT ERRLT ; IF GT OKAY ADD #MINLN,R3 ; Restore MOV R3,RMARG ; SAVE IT RETURN ; ; STANDARD command ; STAND:: MOV #ISPNG*LINSP,NSPNG; SET STANDARD SPACING MOV #ILMRG, LMARG ; INITIALIZE LEFT MARGIN MOV #ITMRG, TMARG ; TOP MARGIN MOV #IRMRG, RMARG ; RIGHT MARGIN MOV IPARIN,PARIND ; SET INITIAL PARAGRAPH INDENT MOV #INLPG*LINSP,R3 ; SET INITIAL PAGE LENGTH PARAMETER BIS #FILLF!JUSTF!PJUSTF,F.1 ;SET TO FILL AND JUSTIFY BR SETPG1 ; FINISH IN COMMON CODE ; ; PAGE SIZE command ; SETPG:: CLRB $PAGNG ; Enable paging MOV PNLPG,R3 ; GET CURRENT PAGE LENGTH CALL (R4) ; GET RELATIVE ARGUMENT JMP 10$ ; Take default CALL CVSP ; Convert to half spacing CMP R3,#MINPG ; LONG ENOUGH TO BE REASONABLE FOR HEADING BLE ERRLT ; Too small ? CMP R3,#377 ; Check max size BGT ERRGT ; Too big ? BR SETPG1 10$: MOV PNLPG,R3 ; Default to current length SETPG1: MOV R3,NLPG ; SAVE AS LENGTH OF THIS PAGE MOV R3,PNLPG ; AND PERMANENT PAGE LENGTH CALL SETRM ; SET RIGHT MARGIN MOV R3,PRMRG ; SET NEW PERMANENT MARGIN CALL SETLM ; GET LEFT MARGIN MOV R3,PLMRG ; SET PERMANENT LEFT CALL SETTM ; GET TOP MARGIN MOV R3,PTMRG ; SET PERMANENT TOP CALL SSP ; Set permenant spacing MOV R3,PSPNG ; Save permenant spacing RETURN ; ; ; The error returns ; ERRGT: MOV #1,R0 ; Param too big BR ERR ERRLT: MOV #2,R0 ; Param too small BR ERR ERRHI: MOV #8.,R0 ; Param too big or negative BR ERR ERRCON: MOV #43.,R0 ERR: JMP ILCMA ; Output the message ; ; SET PARAGRAPH command ; SETPR:: MOV #PARIND,R5 ; Address of paragraph variables CALL (R4) ; OPTIONAL IDENTING ARGUMENT MOV PARIND,R3 ; NO. USE OLD VALUE MOV RMARG,R1 ; Get line size SUB LMARG,R1 CMP R3,R1 ; REASONABLE VALUE? BGT ERRGT ; IF GT NO MOV R3,(R5)+ ; STORE PARA INDENT VALUE CALL 10$ CALL 10$ CALL 10$ RETURN 10$: CALL (R4) ; GET COUNT MOV (R5),R3 ; Default SEC CMP R3,#MAXPS ; Within reason ?? BHI ERRHI MOV R3,(R5)+ ; Save the value RETURN ; ; HALF SPACING command ; NHSPSW:: BISB #SW.DIS,$HSPSW ; Disable half spacing RETURN HSPSW:: BICB #SW.DIS,$HSPSW ; Enable half spacing ; ; SPACING command ; SSP:: CLR R3 ; No initial value CALL (R4) ; GET ARGUMENT OF SPACING command JMP 10$ ; Take default CALL CVSP ; Convert to half spacing CMP R3,#MAXPS*LINSP ; MUST BE IN RANGE 1 to max paragraph spacing BGT ERRGT CMP R3,#LINSP ; Must be at least 1 line BLT ERRLT ; Zero or negative ? BR 20$ ; Save spacing 10$: MOV PSPNG,R3 ; Restore permanent spacing 20$: MOV R3,NSPNG ; OK. STORE AS NORMAL SPACING RETURN ; ; ; PARAGRAPH command ; PARAG:: CALL SETPR ; GET PARAMS JMP PARTP ; And do the paragraph ; ; TEST TEXT command ; TSTTX:: CALL 10$ ; Get top test MOV R1,R5 ; Save value CALL 10$ ; Bottom test MOV R1,R4 ; Bottom test JMP PARTS ; Now test the arguments 10$: CALL (R4) ; Get argument MOV #1,R3 ; Default if no argument MOV R3,R1 ; Number to mul CALL MULSP ; Find actual adjusted line spacing RETURN NOARG: MOV #7,R0 ; Missing argument JMP ILCMA ; ; TEST PAGE command ; TSTPG:: CALL (R4) ; GET ARGUMENT OF TEST MOV #1,R3 ; Default CALL CVSP ; Convert to half spacing MOV R3,R5 ; Save result CALL (R4) ; GET ARGUMENT OF TEST MOV #1,R3 ; Default CALL CVSP ; Convert to half spacing MOV R3,R4 JMP PARTS ; Now test the params ; ; SKIP command ; SKIP:: CALL (R4) ; GET OPTIONAL ARGUMENT MOV #1,R3 ; IF NONE, ASSUME 1 MOV R3,R1 ; Set up to multiply lines x line spacing CALL MULSP ; Find actual adjusted line spacing MOV R1,R2 BR LINSK1 ; ; BLANK command ; LINSKP:: CALL (R4) ; GET OPTIONAL ARGUMENT MOV #1,R3 ; IF NONE, ASSUME 1 CALL CVSP ; Convert to half spacing MOV R3,R2 ; Skip count LINSK1: CMP R2,#377 ; Check size BLE 10$ JMP ERRGT 10$: TSTNEB $PAGNG,11$ ; No paging BITEQ #FOTF,F.1,15$ ; Not currently footnote ? 11$: CMP R2,#MAXPS*LINSP ; Max if footnote BLOS 30$ ; Ok? JMP ERRHI ; No 15$: BITNE #TEXF,F.1,30$ ; text ? TST R2 ; CHECK IF ARGUMENT IS NEG BMI 20$ ; IF NEGATIVE DO NOT MAKE TOP OF PAGE CHECK TSTEQB $PAGBR,50$ ; AT TOP OF PAGE? BR 30$ 20$: ADD LINEC3,R2 ; Skip from bottom 25$: BGT 45$ ; Ok ? MOV #LINSP,R2 ; ELSE JUST SKIP 1 LINE 30$: TSTNEB $PAGNG,45$ ; No paging ? TSTB $PFOOT ; Permanent footnote in progress? BMI 45$ ; Yes CMP R2,LINEC3 ; Test room on page BLE 40$ ; Room still left ? MOV R2,-(SP) ; Save skip CALL BPAGE ; No! make a new page MOV (SP)+,R2 ; Restore 40$: BIS #100000,R2 ; Mark it as optional skip 45$: JMP SKIPN ; YES. SPACE OUT C(R2) LINES 50$: RETURN ; ; ; FIGURE command ; FIGUR:: CALL (R4) ; GET ARGUMENT MOV #1,R3 ; IF NONE, ASSUME ONE LINE CALL CVSP ; Convert to half spacing 10$: CMP R3,#377 ; Check size BLOS 11$ JMP ERRHI 11$: MOV R3,-(SP) ; SAVE DESIRED SPACE MOV R3,R1 CALL TESTP ; TEST IF PAGE SHOULD BE BROKEN MOV (SP)+,R2 ; GET BACK DESIRED SIZE JMP SKIPN ; SPACE THAT OUT ; ; FIGURE DEFERRED command ; FIGDF:: CALL (R4) ; GET ARGUMENT MOV #1,R3 ; IF NONE, ASSUME ONE LINE CALL CVSP ; Convert to half spacing 10$: CMP R3,#377 ; Check size BLOS 11$ JMP ERRHI 11$: MOV R3,-(SP) ; Save CALL TEXTD MOV (SP)+,R2 ; Get skip count CALL SKIPN ; Skip lines JMP ENTEX ; ; FILL/JUSTIFY commands ; JUSTN:: BIS #JUSTF+PJUSTF,F.1 ;TURN ON JUSTIFYING RETURN ; JUSOF:: BIC #PJUSTF+JUSTF,F.1 ;TURN OFF JUSTIFY BITS RETURN ; FILLN:: BIS #FILLF+JUSTF,F.1 ;TURN ON FILLING, COPY PJUSTF TO JUSTF BITNE #PJUSTF,F.1,10$ ;COPY PERMANENT FLAG BIC #JUSTF,F.1 ; TO CURRENT ONE. 10$: RETURN ; FILOF:: BIC #FILLF+JUSTF,F.1 ;TURN OFF FILLING AND JUSTIFYING RETURN ; ; ; TAB STOPS command ; SETTAB::MOV #TABBF,R3 ; Tab buffer CALL CLRBF ; CLEAR NUMBER OF TABS MOV #0,R5 ; Set up test value MOV LMARG,R4 ; Initial starting point 10$: CALL TABPRE ; Get Pretab chars BCS 15$ ; null param MOV R4,R3 ; Default stop CALL RCNR ; GET ANOTHER STOP IF ANY 15$: RETURN ; RETURN ; MOV R3,R1 ; Get value CMP R1,R5 ; Too small? BLE 20$ ; Yes MOV R1,R5 ; Save comparison MOV #TABBF,R3 ; Tab table to save tabs CALL PWRD ; Save a tab CALL TABPOS ; Now save status MOV R5,R4 ; New default value BR 10$ 20$: JMP ILCM ; TABPOS: MOVB STAT,R1 ; status ADD COUNT,R1 ; Plus count CALL PBYT ; To buffer TSTEQ COUNT,20$ ; No count ? MOV ADDR,R0 ; Address of String to transfer CALL PSTRZB ; Transfer it 20$: RETURN TABPRE: CLR COUNT ; Set no count CALL GETLIT ; Get literal BCS 10$ ; None ? MOV R2,ADDR MOV R1,COUNT CMP R1,#TB.CNT-1 ; Is it too big ? BHI 40$ ; Yes 10$: CLR R3 ; No default params CLRB STAT ; No status CALL ALPGT ; Get alpha input BCS 35$ ; None CMPNE R3,#14,20$ ; Is it "L" ? BISB #TB.L,STAT ; Yes BR 35$ 20$: CMPNE R3,#22,30$ ; Is it "R" ? BISB #TB.R,STAT ; Yes BR 35$ 30$: CMPNE R3,#3,31$ ; Is it "C" ? BISB #TB.C,STAT ; Yes BR 35$ 31$: TSTNE R3,40$ ; Is it OK ? SEC BR 36$ 35$: CLC 36$: RETURN ; Yes 40$: JMP ILCM ; ; TAB PROPORTIONAL command ; TABPR:: MOV #TABBF,R3 ; Tab buffer CALL CLRBF ; Cleared CALL (R4) ; Get proportion 1$: RETURN ; Default is no columns RETURN MOV R3,R5 ; Number of tabs BLE 1$ ; Too small MOV RMARG,-(SP) ; Get right margin SUB LMARG,(SP) ; Minus the left CLR R2 ; Number of default tabs 10$: CALL TABPRE ; Get stuff in front of tab BCS 12$ ; Null entry ? CALL RCNO ; Get tab JMP 12$ ; Null entry ? BCC 13$ ; Not + or - 12$: INC R2 SEC ; Make sure it is +- 13$: ROL R3 ; Save carry BCC 14$ BGE 61$ ; Too big ? BR 15$ 14$: BLT 61$ ; Too small ? 15$: MOV R3,R1 MOV #TABBF,R3 ; Buffer to sav in CALL PWRD ; Save tab magnitude ASR R1 ; Strip out carry SUB R1,(SP) BLE 61$ ; Stop too big ? CALL TABPOS ; Add on status SOB R5,10$ ; Continue ? TSTEQ R2,16$ ; No default tabs ? .ifdf $EIS MOV (SP)+,R1 ; Number of spaces left CLR R0 DIV R2,R0 ; Divide by default tabs .iff MOV (SP)+,R0 ; Number of spaces left MOV R2,R1 ; Default tabs CALL $DIV .endc MOV R1,R2 ; Save remainder MOV R0,R5 ; Save field width 16$: MOV LMARG,R4 ; Get current left margin ; ; Now set up tab loop ; MOV #TABBF,R3 ; Get tab buffer CALL BEGBF ; Start at beginning 20$: CALL GWRD ; Get entry BCS 50$ ; Done ? ASR R1 ; Get +- bit BCC 40$ ; Fixed field width ? 30$: ADD R5,R1 ; Add on field width DEC R2 ; Check remainder BLT 40$ ; None left ? INC R1 ; Add 1 to stop 40$: TST R1 ; Check field BLE 61$ ; Not Big enough ? ADD R1,R4 ; Add to current position MOV BF.FUL(R3),R1 ; current index SUB #2,R1 ; Back up CALL FNDBF ; Go back MOV R4,R1 ; To be saved CALL PWRD CALL GBYT ; Get status BIC #^C,R1 ; Strip it ADD BF.FUL(R3),R1 ; Next location CALL FNDBF ; Get it BR 20$ 50$: RETURN 61$: MOV #TABBF,R3 CALL CLRBF ; Clear out bad tabs JMP ILCM ; Value too small ; ; CENTER command ; CENTRT:: BISB #SW.DIS,$CENSW ; CENTER LINES TILL END CENTER:: BISB #SW.TDS,$CENSW ; Set up temporary center this line TSTNE INDCT,5$ ; Currently set indentation ? TSTEQB $RIGSW,10$ ; Not right justified ? 5$: CLRB $CENSW ; Clear centering JMP ERRCON 10$: MOV RMARG,R3 ; RIGHT ADD LMARG,R3 ; PLUS LEFT CLC ASR R3 ; DIVIDED BY 2 MOV R3,CMARG ; DEFAULT CALL (R4) ; GET RELATIVE ARG MOV CMARG,R3 ; DEFAULT MOV R3,CMARG ; CENTERING MARGIN RETURN ; ; END CENTER command ; END RIGHT command ; ECENT:: BICB #SW.DIS,$CENSW ; CLEAR CENTERIN SWITCH ERIGHT::BICB #SW.DIS,$RIGSW ; Reset permanent right shift CLR INDCT RETURN ; ; RIGHT command ; RIGHT TEXT command ; RIGHT:: BISB #SW.DIS,$RIGSW ; Set permanent right justify switch RIGHJ:: BISB #SW.TDS,$RIGSW ; Set temporary righj justify switch TSTEQB $CENSW,10$ ; Not centered justified ? CLRB $RIGSW ; Clear right justify JMP ERRCON 10$: CALL (R4) ; Get shift MOV #0,R3 ; Default JMP INDCK ; Check indent ; ; PERMANENT FOOTNOTE command ; PERFN:: TSTNEB $PAGNG,ILLEG ; No paging ? TSTNEB $FOTPD,10$ ; Footnote pending? MOVB #-1,$PFOOT ; Indicate permanent footnote MOV #FOTBF,R3 ; Get footnote buffer CALL CLRBF ; Clear it CLR FOTLN ; Clear number of lines of footnote CLR PFOTHD ; Clear permanent footnote header BR FOOT1 ; Do not set pending 10$: MOV #33.,R0 ; Can't do permanent footnote JMP ILCMA ILLEG: JMP ILCM ; ; FOOTNOTE command ; FOOTN:: TSTNEB $PAGNG,ILLEG ; No paging ? TSTNEB $FOTPD,10$ ; No footnote pending? DECB $FOTPD ; Footnote now pending SUB FOTLN,LINEC3 ; Test if enough room MOV FOTLN,FOTBF+BF.VSP ; Set up footnote size 10$: MOV NSPNG,R1 ; Number of blanks/line CALL TESTP ; Test it FOOT1: MOV #FOTSV,R0 ; FOOTNOTE SAVE BUFFER MOV #SAVBEG,R1 ; PARAMS TO SAVE MOV #SAVSZ,R2 ; SIZE OF SAVE BUFFER 10$: MOVB (R1)+,(R0)+ ; SAVE EM SOB R2,10$ ; TILL DONE CLR INDCT ; CLEAR INDENTATION TSTB $PFOOT ; Permanent params? BLE 30$ ; No ? MOV #PFTSV,R0 ; Footnote permanent save buffer MOV #PFSBEG,R1 ; Table to restore MOV #PFSIZ,R2 ; # of bytes to save 20$: MOVB (R0)+,(R1)+ ; SAVE EM SOB R2,20$ ; TILL DONE 30$: BIS #FOTF,F.1 ; PUT OUTPUT INTO FOOTNOTE BUFFER RETURN ; ; ; END FOOTNOTE ; FOOTE:: BITEQ #FOTF,F.1,20$ ; Footnote not in progress? CALL OUTAD ; Get footnote buffer TSTB $PFOOT ; Permanent footnote in progress? BGE 5$ ; No? MOV BF.VSP(R3),R0 ; Get footnote size CMP R0,#12. ; Check size BLOS 1$ ; OK ? CALL CLRBF ; Clear the footnote buffer MOV #ILCMA,-(SP) ; How to end 1$: MOVB #1,$PFOOT ; Set not in progress, but on MOV BF.VSP(R3),FOTLN; Save permanent footnote size MOV BF.FUL(R3),PFOTHD; Save header address MOV #PFTSV,R0 ; Footnote permanent save buffer MOV #PFSBEG,R1 ; Table to save MOV #PFSIZ,R2 ; # of bytes to save 3$: MOVB (R1)+,(R0)+ ; SAVE EM SOB R2,3$ ; TILL DONE 5$: MOV #FOTSV,R0 ; FOOTNOTE SAVE BUFFER MOV #SAVBEG,R1 ; PARAMS TO RESTORE MOV #SAVSZ,R2 ; SIZE OF SAVE BUFFER 10$: MOVB (R0)+,(R1)+ ; RESTORE EM SOB R2,10$ ; TILL DONE MOV #47.,R0 ; Error message RETURN ; 20$: MOV #28.,R0 ; Unexpected END FOOTNOTE JMP ILCMA ; Output error message ; ; TEXT commands ; TEXTC:: TSTNEB $PAGNG,TXRET ; No paging ? CALL ENTEX ; Output previous text TSTEQB $PAGBR,TXRET ; Already at top of page? BIS #TEXF,F.1 ; Deferred text flag TXRET: RETURN ; ; END TEXT command ; ENTEX:: TSTNEB $PAGNG,TXRET ; No paging ? TSTNEB $SBPSW,ERRSBP ; Subpage ? BITEQ #TEXF,F.1,TXRET ; Not in text mode ? BITNE #TXDEF,F.1,10$ ; Currently text deferred ? BIC #TEXF,F.1 ; No longer JMP OUTNJ ; Now output the text 10$: CALL TXDEND ; End the deferred text CALL TXDOUT ; And any deferred text RETURN ; ERRSBP: MOV #37.,R0 ; Illegal during subpage JMP ILCMA ; ; TEXT DEFERRED command ; TEXTD:: TSTNEB $PAGNG,10$ ; No paging ? CALL ENTEX TSTEQB $PAGBR,10$ ; Already at top of page? BIS #TXDEF!TEXF,F.1 ; Set up for deferred text MOV LINEC3,LN3SAV ; Save current number of lines MOV NLPG,R0 ; Number of lines SUB TMARG,R0 ; Minus top margin BITNEB #^C,$HDRSW,5$ ; No header ? SUB #LINSP,R0 ; Minus title SUB HSPAC,R0 ; Minus subtitle 5$: SUB $EOPSP,R0 ; Minus space at bottom MOV R0,LINEC3 ; Now potential lines CALL OUTAD ; Get buffer address CALL ENDBF ; Go to end of buffer CLR BF.VSP(R3) ; No vertical spacing yet MOV BF.FUL(R3),TXDHED ; Save header MOV #HD.TXD*400,R1 ; Will be line count CALL PWRD ; Save text defered header 10$: RETURN ; ; PAGE command - produces a new page ; NEWP0: TSTEQB $SBPSW,NEWPAG ; Not Subpage ? JMP ERRSBP NEWPAG::BITEQ #TEXF,F.1,20$ ; NOT in text or text def section ? CALL OUTAD MOV LINEC3,R2 ; Skip to end of page CALL SKIPN JMP ENTEX ; End the text section 20$: MOVB $PAGNG,-(SP) ; Save paging status CLRB $PAGNG ; Set paging on CALL CPAGE ; Start new page MOVB (SP)+,$PAGNG ; Restore paging status RETURN ; ; PAGE EVEN command - Produce even numbered page ; PAGEV:: CALL NEWP0 ; Start new page BITNE #1,PAGENO,SKPAG ; Page odd ? RETURN ; ; PAGE ODD command - Produce odd numbered page ; PAGOD:: CALL NEWP0 ; Start new page BITEQ #1,PAGENO,SKPAG ; Current page even ? RETURN SKPAG: JMP BPAGE ; Bread for page ; ; ENABLE ODD command ; ENODD:: BISB #SW.TDS,$ODPAG ; ENable odd pages RETURN DISODD::BICB #SW.TDS,$ODPAG ; Disable odd pages RETURN .END