.TITLE FMTCM .IDENT /M03.1/ ; ; ; ; J. CLEMENT - 1983 ; Rewrote most of the code ; ; RUNOFF COMMANDS ; CHAPTER ; APPENDIX ; NOTE ; LIST, LIST ELEMENT, END LIST ; TITLE, SUBTITLE ; HEADER page commands ; HEADER LEVEL ; ; ; ALL COMMAND ROUTINES ARE ENTERED WITH: ; ; R4=ADDRESS OF NUMBER CONVERSION ROUTINE. ; ; LOCAL DATA ; ; OUTPUT TEXT ; .PSECT $TEXT,RO,D,LCL,CON LOWER: .ASCIZ /page / MIXED: .ASCIZ /Page / UPPER: .ASCIZ /PAGE / NOTET: .ASCIZ /NOTE/ ; NOTE HEADING PROTOTYPE MRGERR: .ASCIZ /RNO -- Can't Reduce margins/ IFTXT: .BYTE TOCX,200 .ASCIZ /.IF TOC/ EITXT: .BYTE TOCX,200 .ASCIZ /.ENDIF TOC/ .EVEN .PSECT TABL,RO,LCL,CON,D LVTAB: .WORD LVHD1A,LVHD1B,LVHD2A,LVHD2B,LVHD3A,LVHD3B .WORD LVHD4A,LVHD4B,LVHD5A,LVHD5B,LVHD6A,LVHD6B .PSECT $VARS,RW,D,lcl,con LTAB: .WORD 0 LTST: .WORD 0 LSAV: .word 0 LSTAT: .word 0 .PSECT $CODE,RO,LCL,CON,I ; ; APPENDIX COMMAND ; APNDX:: CALL CHAP0 ; Pre chapter actions MOV #APNM2,-(SP) ; Post header CLR -(SP) ; end for number conversion MOVB APNNX,APNDN ; current appendix number MOVB APNNX,-(SP) ; For output INCB APNNX ; increment appendix number BNE 10$ ; Non zero? INCB APNNX ; Make it 1 MOVB APNNX,-(SP) 10$: CLRB 1(SP) BIS APNDSP,(SP) ; set format MOV #APNMG,-(SP) ; SET ADDRESS OF APPENDIX HEADING MOV #APSTAT,R2 ; Appendix status BR CHAP1 ; ; ; CHAPTER COMMAND ; CHPTR:: CALL CHAP0 ; Pre chapter actions MOV #CHPM2,-(SP) ; Post header CLR -(SP) ; end of numbers MOVB CHPNX,CHPTN ; current number MOV CHPNX,-(SP) ; for output INCB CHPNX ; incrment chapter number BNE 10$ ; Non zero? INCB CHPNX ; No, make it 1 10$: CLRB 1(SP) BIS CHPDSP,(SP) ; format MOV #CHPMG,-(SP) ; SET ADDRESS OF CHAPTER HEADING MOV #CHSTAT,R2 ; Set for chapter status BR CHAP1 ; ; Common code for .CHAPTER or .APPENDIX ; CHAP0: CLRB $PAGNG ; Enable paging CALL TXDMP ; Dump all deferred text CLRB LEVEL ; Current level # CALL ESCCLR ; Clear escapes and underlining CLRB CHPTN+1 ; And clear current header level MOV #STLBF,R3 ; CLEAR SUBTITLE BUFFER CALL CLRBF BITNEB #SW.DIS,$AUTTL,5$ ; No auto title? CALL TTLSV ; Save title 5$: TSTNEB $TOCBE,30$ ; TOC in progress ?? MOV PTMRG,TMARG ; SET TOP MARGIN MOV PLMRG,LMARG ; Left margin MOV PRMRG,RMARG ; SET RIGHT MARGIN CLRB $CENSW ; Clear centering just in case CALL STCMRG ; Set center margin MOV PSPNG,NSPNG ; SET INITIAL SPACING BIS #FILLF!JUSTF!PJUSTF,F.1 ;SET FILL AND JUSTIFY FLAGS TSTEQB $ODPAG,10$ ; Odd page not enabled ? BITNE #1,PAGNX,10$ ; Next page odd ? CALL PAGRST INCB $PAGBR ; Set no current page 10$: BISB #SW.TDS,$HDRSW ; no header at begin chapters/appendix MOVB CHLAY,R0 ; Any chapter layout ? BLT 20$ ; No ? MOVB R0,NXLAY ; Next layout MOV CHEPSP,NXEPSP ; And end of page spacing 20$: CALL PAGRST ; Break page + reset subpage 30$: RETURN CHAP1: CALL RSTAT ; Restore status if available CALL BUFTOC ; Send command to TOC MOVB CHSK1,R2 ; SET LINE COUNT CALL SKIPN ; Skip lines TSTEQB $TOCBE,10$ ; TOC not in progress ?? MOV PARPT,R1 ; use paragraph test page CALL TESTT ; To test page 10$: CALL LINBEG ; Start new line MOVB CHSP1,R2 ; First space count CALL CENCH ; Use em MOV (SP)+,R2 ; chap/appendix pre-heading CALL HDOUT ; Convert headers CLR BF.SPC(R3) ; Number of spaces CALL PAGCV ; convert numbers MOV BF.SPC(R3),R0 ; Spacing chars ADD R0,SPCH ; Total spacing chars SUB R0,LINBK ; Chars this line MOV (SP)+,R2 ; chap/appendix post-heading CALL HDOUT ; Convert headers TSTB CHSK2 ; Next one on same line? BMI 20$ ; Yes CALL OUTNJ ; No MOVB CHSK2,R2 ; Number of line CALL SKIPN ; Skip them 20$: CALL LINBEG MOVB CHSP2,R2 ; Second space count CALL CENCH ; Use em BISB #SW.IDS,$AUHYP ; Prevent automatic hyphenation BISB #SW.IDS,$EQFSW+1; Prevent equations CALL LINUC ; Transfer lines to buffer BICB #SW.IDS,$EQFSW+1; Allow equations BICB #SW.IDS,$AUHYP ; Now allow it again CALL ENDESC TSTB CHSK3 ; Next one on same line? BMI 30$ ; Yes CALL OUTNJ ; Output it MOVB CHSK3,R2 ; Lines to skip CALL SKIPN ; Skip them 30$: JMP LGO ; Next line ; ; Clear escape sequences pending & underlining ; ENDESC: TSTEQ BF.HED(R3),ESCCLR ; No buffer ? MOV ESMSK,R4 ; Escape sequences on CALL ESCEND ; End them ESCCLR: CLR ESMSK ; Clear escapes MOV #1,PHSP ; Reset permanent spacing BISB #SW.TDS,$UNLSW ; Set temporary disable RETURN ; ; Set up centering or margin ; CENCH: TST R2 ; Type of spacing BGE 5$ ; No centering? CMPNE R2,#-1,4$ ; Not centering? BISB #SW.TDS,$CENSW ; Set to center RETURN 4$: BISB #SW.TDS,$RIGSW ; Set to right justify RETURN 5$: MOV #TABO,R1 ; Output N spaces CALL PBYT MOV R2,R1 CALL PBYT ADD R2,SPCH ; Spacing chars SUB R2,LINBK ; Chars left in line RETURN ; ; Save TITLE in uppercase ; TTLSV: TSTNEB $TOCBE,STLSV2 ; TOC in progress? MOV BUFADD,R0 ; Input buffer MOV BF.FUL(R0),-(SP) ; Save current location CALL UCTTL ; Save current input in tittle BR STLSV1 STLSV: TSTNEB $TOCBE,STLSV2 ; TOC in progress? MOV CASE,STLCAS MOV BUFADD,R0 ; Input buffer MOV BF.FUL(R0),-(SP); Save current location CALL SETST1 ; Save current input in tittle STLSV1: MOV (SP)+,R1 ; Location to back to MOV BUFADD,R3 ; Input buffer CALL FNDBF ; Go back to previous location MOV #TX2BF,R3 ; Restore output buffer STLSV2: RETURN ; ; Output buffer to TOC ; BUFTOC: TSTNEB $TOCSW,10$ ; No TOC? MOV BUFADD,R3 ; Get input buffer address MOV ERSTR,R1 ; Start of command MOV BF.CNT(R3),R2 ; String count ADD BF.ADD(R3),R2 SUB R1,R2 DEC R2 ; Omit CR,LF CALL OUTTOC ; Output to TOC file MOV #TTBF,R3 ; Get temporary buffer CALL CLRBF MOV #TAB,R1 ; Tab to output CALL PBYT ; To temporary buffer CALL PUTPAG ; Page number into buffer MOV BF.FUL(R3),R2 ; Count MOV BF.ADD(R3),R1 ; Address INC R1 ; Plus 1 SUB R2,R1 ; Start address JMP OUTTOC ; Output to TOC 10$: RETURN ; ; HEADER COMMAND ; .ENABL LSB HEADU:: MOV #UPPER,R0 ; Header upper BR HEAD1 HEADM:: MOV #MIXED,R0 ; Header mixed BR HEAD1 HEADL:: MOV #LOWER,R0 ; Header lower HEAD1: MOV #PAGHD,R1 ; POINT TO PAGE HEADER AREA 40$: MOVB (R0)+,(R1)+ ; MOVE PROTOTYPE BNE 40$ ; IF NE MORE TO GO HEADP:: BICB #SW.DIS,$HDRSW ; Set to print page headers RETURN ; 50$: CALL CCIN ; READ NEXT CHARACTER CMPNEB GCTABL(R1),#GC.LC,60$ ; not lower case? BIC #40,R1 ; CONVERT TO UPPER CASE 60$: RETURN ; ; ; NOHEADER COMMAND ; NHEAD:: BISB #SW.DIS,$HDRSW ; SET TO NOT PRINT PAGE HEADERS RETURN ; .DSABL LSB .ENABL LSB ; ; HEADER PAGE COMMANDS ; HPAGE:: CLRB $PAGSW ; SET 'PAGE' ON RETURN ; HNOPG:: MOVB #-1,$PAGSW ; SET 'PAGE' OUTPUT OFF RETURN ; ; ; HEADER SPACING ; HEDSP:: CALL (R4) ; GET PARAMETER JMP 10$ ; Default CALL CVSP ; Convert vertical spacing BR 20$ 10$: MOV NSPNG,R3 ; USE LINE SPACING AS DEFAULT 20$: CMP R3,#MAXPS*LINSP ; TOO BIG? BGT ERRGT ; Too big ? CMP R3,#LINSP ; Check lower bound BGE 30$ ; Big enough ? MOV #LINSP,R3 ; Set it to line spacing 30$: MOV R3,HSPAC ; SAVE HEADER SPACING RETURN ERRGT: MOV #1.,R0 ; Param error message BR ERR ERRLT: MOV #2,R0 ; Too small error message ERR: JMP ILCMA .DSABL LSB ; ; HEADER LEVEL COMMAND ; HEADR:: CLR LTST MOVB LEVEL,R3 ; Initial level # CALL (R4) ; GET HEADING LEVEL NUMBER MOVB LEVEL,R3 ; Default is current level TST R3 ; Is level too small? BGT 10$ ; No 5$: MOV #2,R0 ; Param too big BR 7$ 6$: MOV #3,R0 ; Param too big 7$: JMP ILCMA 10$: CMP R3,#6. ; Level too big? BGT 6$ ; Param too big MOVB LEVEL,R2 ; Previous level MOVB R3,LEVEL ; Save level number ADD #CHPTN,R3 ; Point to current level ADD #CHPTN+1,R2 ; Point to previous level + 1 INCB (R3) ; Increment current level CLRB 1(R3) ; Clear next level CMP R3,R2 ; Current > previous BLO 20$ ; No 15$: MOVB #1,(R2)+ ; Set levels to 1 CMP R2,R3 ; Past current level? BLOS 15$ ; Not yet 20$: CMPB LEVEL,OUTLV ; Current level too big? BLE 25$ ; Level number is ok JMP LCR ; Kill text at end of command. 25$: TSTEQB $AUSTL,27$ ; No autosubtitle? CMPB LEVEL,STLLV ; Level low enuf? BGT 27$ ; No MOV CASE,-(SP) ; Save current case CALL SETCAS ; Set correct case CALL STLSV ; Set up subtitle MOV (SP)+,CASE ; Restore 27$: MOVB BEGLV,R2 ; SET LINE COUNT BEQ 30$ ; None CALL SKIPN ; Skip lines by line count 30$: MOVB TPGLV,R1 ; SET TEST PAGE VALUE CALL TESTT ; Test if room on current page CMPB LEVEL,TOCLV ; Do TOC this level? BGT 35$ ; No !! CALL BUFTOC ; Output command to TOC 35$: CALL LINBEG ; Start new line MOV #LVSTAT,R2 ; Level status buffer CALL RSTAT ; Restore status MOVB LEVEL,R2 ; GET LEVEL # DEC R2 ASL R2 ; BYTE ADDRESS ASL R2 ; DOUBLE WORD ADDRESS MOV R2,LSAV ; Save level index TSTNEB @LVTAB(R2),37$ ; Header ?? TSTEQB @LVTAB+2(R2),38$; No second header ?? 37$: CALL ESCCLR ; Set No escapes or underlining INC LSTAT ; Set escape set MOV LVTAB(R2),R2 ; heading CALL HDOUT ; Convert headers 38$: CMPB LEVEL,NONLV ; No number level BGE 70$ ; Yes MOV #CHPTN,R2 ; POINT TO CHAPTER/LEVEL TABLE CLR -(SP) ; end of numbers CMPB LEVEL,UNILV ; Unitary level number BLE 39$ ; Not unitary ?? MOVB LEVEL,R0 ; Get level # ADD R0,R2 ; Now points to correct one BR 50$ 39$: MOVB APNDN,R1 ; Current appendix number BEQ 40$ ; IF EQ NONE MOV R1,-(SP) ; appendix to convert BIS APNDSP,(SP) ; format BR 45$ ; Continue with rest of levels 40$: TSTNEB (R2),50$ ; Chapter oriented document? 45$: INC R2 ; Skip chapter number 50$: MOVB (R2)+,R1 ; Current chapter or level number BEQ 60$ ; Last one? MOV R1,-(SP) ; save for conversion MOVB CHPDSP-CHPTN(R2),1(SP) ; set display format BR 50$ ; more 60$: MOVB #'.,$SEPR ; digit separator CLR BF.SPC(R3) ; Number of spaces CALL PAGCV ; convert numbers MOV BF.SPC(R3),R0 ; Spacing chars ADD R0,SPCH ; Total spacing chars SUB R0,LINBK ; Chars this line CMPB LEVEL,UNILV ; Unitary level number BGT 65$ ; Unitary ?? TSTNEB APNDN,65$ ; Chapter oriented? CMPNEB LEVEL,#1,65$ ; Not first level? TSTNEB CHPTN,65$ ; Chapter oriented? MOVB #'.,R1 ; Output .0 CALL CCBYT ; Now . MOVB #'0,R1 ; Output 0 CALL CCBYT ; Now 0 65$: MOV LSAV,R2 MOV LVTAB+2(R2),R2 ; post-heading CALL HDOUT ; Convert headers MOVB SPCLV,R4 ; Get number of spaces to indent BLE 70$ ; None! MOV #NXS,R1 ; Get quoted space to write 68$: CALL CCBYT ; SOB R4,68$ ; Output all spaces 70$: MOV RMARG,-(SP) ; Save right margin MOV LMARG,-(SP) ; Save margin MOV LIDLV,R1 ; Margin changes MOV RIDLV,R2 CALL SETMRG ; Set them 80$: CALL CCIN ; Get next input char CMPEQB R1,#SPC,80$ ; Space? CMPEQB R1,#TAB,80$ ; Tab? CALL BKSPI ; Backspace input CMPEQB R1,#CR,120$ ; End of line? MOV CASE,-(SP) ; Save current case CALL SETCAS ; Set correct case CMPB LEVEL,CENLV ; Not center it? BLT 90$ ; Yes CMPB LEVEL,LINLV ; Run in level BGE 90$ ; Yes, do not center it BISB #SW.TDS,$CENSW ; Set to center it BR 92$ 90$: MOV SPCH,R1 ; Check on total char count CLR R2 ; No right margin change CALL SETMRG ; Try to reset margin BCS 92$ ; Yes skip margin change ADD R1,LINBK ; Reset chars/line NEG R1 MOV R1,INDCT ; Negative indentation first time 92$: BISB #SW.IDS,$AUHYP ; Prevent hyphenation BISB #SW.IDS,$EQFSW+1; Prevent equations BISB #SW.IDS,$IFLSW+1; Prevent indexing CALL LIN ; Transfer lines to buffer MOVB LEVEL,R2 ; GET LEVEL # DEC R2 ASL R2 ; BYTE ADDRESS ASL R2 ; DOUBLE WORD ADDRESS TSTEQ LSTAT,93$ ; Pre-header not used ?? CALL ENDESC 93$: BICB #SW.IDS,$EQFSW+1; Allow equations BICB #SW.IDS,$AUHYP ; Now allow it again BICB #SW.IDS,$IFLSW+1; Now allow it again MOV (SP)+,R1 ; Old case MOV R1,CASE ; No, restore previous MOV R1,CASSAV ; And saved case 95$: TSTNEB $TOCBE,120$ ; TOC in progress? CMPB LEVEL,LINLV ; Level >= run on line value BGE 110$ ; Yes CALL OUTNJ ; OUTPUT HEADING LINE BICB #SW.TDS,$CENSW ; Reset centering MOVB ENDLV,R2 ; SET LINE COUNT BEQ 100$ ; None CALL SKIPN ; Skip lines 100$: MOV (SP)+,LMARG ; Restore margins ADD (SP),LINBK ; Reset line length SUB RMARG,LINBK ; MOV (SP)+,RMARG ; JMP LGO 110$: CALL LINBEG CMP LINBK,#3 ; Room for 3 more? BLE 120$ ; No MOVB #NXS,R1 ; insert space CALL CCBYT MOVB #'-,R1 ; insert dash CALL CCBYT MOV #NXS,R1 ; insert space CALL CCBYT 120$: ADD LMARG,INDCT ; Now set up indentation SUB (SP),INDCT ; = current - old margin + Old indentation BR 100$ ; ; routine to set correct case ; SETCAS: CMPB LEVEL,MIXLV ; Capitalize first char? BGT 10$ ; No BIS #1002,CASE ; Yes 10$: CMPB LEVEL,CAPLV ; Higher than min capitalize level BGT 20$ ; Yes MOV #401,CASE ; Shift to upper case 20$: RETURN ; ; LIST command ; LISTC:: CALL GETVS ; Get list vertical spacing CLR -(SP) ; Clear list char CALL GETLIT ; Now get literal BCS 1$ ; None ? MOVB (R2),(SP) ; Character to use in list 1$: MOV LSTKP,R4 ; GET CURRENT LIST STACK POINTER CMP R4,#TKPEND ; LIST STACK OVERFLOW? BHIS 40$ ; IF HI YES MOV #LSLMAR,R1 ; ASSUME EMBEDDED LIST INDENT CMPNE #LSTK,R4,10$ ; NOT FIRST ITEM IN STACK? MOV #LOLMAR,R1 ; SET FOR INITIAL LIST INDENT 10$: CLR R2 MOV LMARG,LS.MRG(R4); SAVE LEFT MARGIN ADD #LS.SIZ,R4 MOV R4,LSTKP ; New stack address MOVB (SP)+,LS.CHR(R4); Save character MOVB R3,LS.VSP(R4) ; SET NEW LIST VERTICAL SPACING CLR (R4) ; CLEAR CURRENT LIST ELEMENT NUMBER CALL SETMRG ; Set margin BCS 30$ ; Bad ? RETURN 30$: MOV #13.,R0 ; Warn user about overlap error BR 50$ 40$: MOV #35.,R0 ; List level overflow 50$: JMP ILCMA ; Output error message ; ; Get the vertical spacing ; GETVS: CALL (R4) ; Get list vertical spacing MOV PARSP,R3 ; Default spacing CMP R3,#MAXPS ; LEGAL VALUE? BLOS 20$ ; yes ? JMP ERRHI ; IF HI NO RETURN 10$: MOV PARSP,R3 ; Paragraph spacing 20$: RETURN ERRHI: MOV #8.,R0 ; Param too big or negative JMP ILCMA ; ; END LIST COMMAND ; ELIST:: CALL GETVS ; Get final vertical spacing MOV LSTKP,R4 ; GET CURRENT LIST STACK POINTER CMP R4,#LSTK ; Unexpected end? BLOS 20$ ; Yes, Do not unstack SUB #LS.SIZ,R4 ; New address MOV R4,LSTKP ; SAVE NEW LIST STACK POINTER MOV LS.MRG(R4),LMARG ; Restore left margin MOV R3,R1 ; Final skip count JMP SKPLIF ; Skip lines if not at top of page 20$: MOV #30.,R0 ; Unexpected endlist JMP ILCMA ; Output error message ; ; LIST ELEMENT COMMAND ; LSTEL:: MOV LSTKP,R4 ; Get stack pointer MOVB LS.VSP(R4),R1 ; GET LIST ELEMENT VERTICAL SPACING CALL SKPLIF ; SKIP LINES CALL PART0 ; Break page if necessary MOV LSTKP,R4 ; Get stack pointer INC (R4) ; INCREMENT LIST ELEMENT NUMBER BNE 10$ ; Non zero? INC (R4) ; INCREMENT LIST ELEMENT NUMBER 10$: CMP (R4),#4000. ; Too big ? BLO 15$ ; No MOV #1,(R4) ; Reset it 15$: CALL LINBEG ; Begin new line MOV LSTKP,R4 ; Current list stack MOVB LS.CHR(R4),R1 ; Get list character BNE 30$ ; Any ? MOVB LS.PRE(R4),R1 ; Get first char CMP R1,#SPC ; Space or less? BLE 20$ ; Yes, do not output it CALL CCBYT ; Save it 20$: CLR -(SP) ; chock MOV (R4),-(SP) ; GET CURRENT ELEMENT NUMBER BISB LS.FMT(R4),1(SP); Set the format bits CLR BF.SPC(R3) ; Number of spaces CALL PAGCV ; convert numbers MOV BF.SPC(R3),R0 ; Spacing chars ADD R0,SPCH ; Total spacing chars SUB R0,LINBK ; Chars this line MOV LSTKP,R4 ; Restore MOVB LS.PST(R4),R1 ; Second char CMP R1,#SPC ; Space or less? BGT 30$ ; No, char is OK MOV #'.,R1 ; GET PERIOD 30$: CALL CCBYT ; WRITE PERIOD INTO BUFFER MOV #NXS,R1 ; GET NON EXPANDABLE SPACE CALL CCBYT ; WRITE QUOTED SPACE INTO BUFFER CALL CCBYT ; WRITE ANOTHER QUOTED SPACE MOV SPCH,R1 ; Char count MOV LMARG,R0 ; Check left margin SUB PLMRG,R0 ; Find difference from permenant margin BLE 50$ ; smaller SUB R1,R0 ; Is indent too large? BGE 40$ ; No ADD R0,R1 ; Yes, correct it ADD R0,LINBK ; Subtract extra from line counter 40$: NEG R1 ; Indent to left of current margin MOV R1,INDCT ; Indentation 50$: CALL $FRCND ; FORCE TO LOGICAL END OF COMMAND TST (SP)+ ; CLEAN STACK JMP TEXTF ; Process text immediately ; ; END NOTE COMMAND ; ENOTC:: BITEQ #NOTF,F.1,20$ ; Note not in progress? MOV NOTSV,F.1 ; RESTORE FLAGS WORD MOV NOTRM,RMARG ; INCREASE RIGHT MARGIN MOV NOTLM,LMARG ; DECREASE LEFT MARGIN CALL (R4) ; Get skip after note MOV #NFSPAC,R3 ; SET SKIP COUNT MOV R3,R1 CMP R1,#MAXPS ; Compare with maximum paragraph spacing BLOS 10$ ; Ok ? JMP ERRHI ; Too big ? 10$: JMP SKPLIF ; SKIP LINES 20$: MOV #29.,R0 ; Message number JMP ILCMA ; Bad end note ; ; NOTE COMMAND ; NOTE:: MOV #NHSPAC,R1 ; Pre line count CALL SKPLIF ; SKIP LINES MOV LMARG,NOTLM ; Save margins MOV RMARG,NOTRM ; Save margins MOV RMARG,R0 ; Get right margin SUB LMARG,R0 ; Minus left margin ASR R0 ; Half of difference ASR R0 ; One fourth of difference ASR R0 ; Now 1/8 MOV #NPMARG,R1 ; Note margin 5$: CMP R0,R1 ; Margin too wide? BGE 10$ ; No ? SUB #NSMARG,R1 ; Secondary indent BGT 5$ ; Not zero ADD #NSMARG,R1 ; Secondary indent 10$: CALL SETMRS ; Margins set? BCC 20$ ; Yes 15$: MOV #MRGERR,R0 ; Error message CALL EROUT ; Output error CALL ONLIN ; OUTPUT PAGE NUMBER 20$: MOV F.1,NOTSV ; SAVE CURRENT FLAGS WORD BIS #FILLF!JUSTF!PJUSTF!NOTF,F.1 ;SET FLAGS MOV #NASPAC+1,R1 ; post line count ADD PARPT,R1 ; Plus test page count CALL PART1 ; Use paragraph test page CALL LINBEG ; Start new line BISB #SW.TDS,$CENSW ; SET UP TO CENTER TEXT BISB #SW.IDS,$IFLSW+1; Prevent indexing BISB #SW.IDS,$EQFSW+1; Prevent equations CALL $FRCND CMPEQ R1,#CR,25$ ; End of line ? CALL GCIN ; Get line CALL BKSPI ; Backspace to LF TSTNE SPCH,30$ ; Any text ? 25$: MOV #NOTET,R2 ; POINT TO NOTE TEXT PROTOTYPE CALL TMPIN ; Set up in buffer CALL GCIN 30$: BICB #SW.IDS,$EQFSW+1; Allow equations BICB #SW.IDS,$IFLSW+1; Now allow it again MOV #NASPAC,R1 CALL MULSP ; Get line adjusted MOV R1,EQBOT ; SET bottom LINE COUNT JMP OUTLIN ; OUTPUT THE TEXT ; ; Routine to reduce margins ; ; R1=left reduction ; r2=right reduction ; r0=destroyed ; SETMRS: MOV R1,R2 ; Both left and right SETMRG: MOV RMARG,R0 SUB LMARG,R0 SUB R1,R0 SUB R2,R0 ; Total margins CMP R0,#MINLN ; Too small?? BGE 1$ ; No SEC RETURN 1$: MOV #LMARG,R0 ; Margin ADD R1,(R0) ; New left CMP (R0)+,PLMRG ; Is left margin big enough? BGE 10$ ; Yes ADD -(R0),R1 ; Compensate R1 SUB PLMRG,R1 ; Now is actual indent MOV PLMRG,(R0)+ ; And is permenant margin 10$: SUB R2,(R0) ; New right CMP (R0),PRMRG ; Is right margin small enough? BLE 20$ ; Yes SUB (R0),R2 ; Compensate R2 ADD PRMRG,R2 ; Now is actual indent MOV PRMRG,(R0) ; And is permenant margin 20$: SUB R1,LINBK ; New char count SUB R2,LINBK ; New char count CALL STCMRG ; No! CLC RETURN ; ; Set up center margin ; STCMRG: MOV RMARG,R0 ; Get right margin ADD LMARG,R0 ; Sum of right and left margins ASR R0 ; Divide by 2 MOV R0,CMARG ; Set for center margin RETURN ; ; put byte and incrment counter ; CCBYT: CMPNEB R1,#SPC,10$ ; not space? INC SPCNT ; increment space count 10$: INC BF.SPC(R3) ; Count spacing chars INC SPCH ; " " " DEC LINBK ; Remaining chars JMP PUBYT ; Put underlined byte ; ; SUBTITLE COMMAND ; SETSTL::CLR #STLCAS SETST1: MOV #STLBF,R3 ; SUBTITLE BUFFER MOV #STLHD2,-(SP) ; Header addresses MOV #STLHD1,-(SP) ; Header addresses BR SETBF ; ; ; no title command ; NTITL:: MOVB #-1,$NTITL ; set no title print RETURN ; ; FIRST TITLE COMMAND ; UCTTL: MOV #401,TTLCAS ; Shift to upper case BR SETTL1 FTITL:: BITNE #LCKF,F.1,SETTL ; Params locked? CLRB $HDRSW ; ENABLE HEADER ON FIRST PAGE ; ; TITLE COMMAND ; SETTL:: CLR TTLCAS ; No title case settl1: MOV #TTLBF,R3 ; SET FOR TITLE BUFFER BITEQ #LCKF,F.1,10$ ; param not locked? CLRB $NTITL ; set for print of titles 10$: MOV #TTLHD2,-(SP) ; Header addresses MOV #TTLHD1,-(SP) ; Header addresses SETBF: CALL CLRBF ; SET BUFFER EMPTY MOV (SP)+,R2 ; Get pre-header CALL TRANSB CALL $FRCND ; FORCE TO LOGICAL END OF COMMAND CLR BF.SPC(R3) ; No chars now 10$: CALL CCIN ; READ TITLE OR SUBTITLE CMPEQB R1,#CR,15$ ; Done ?? CALL PBYT ; Save the char INC BF.SPC(R3) ; Count chars. BR 10$ ; Continue with more 15$: MOV (SP)+,R2 ; Get pre-header CALL TRANSB TSTNE BF.SPC(R3),17$ ; Any chars stored ?? CALL CLRBF BR 20$ ; No title/subtitle 17$: MOV BF.FUL(R3),BF.SPC(R3) ; Get total char count TSTNEB $HDSTS,20$ ; Permanent status set ? MOV #HDSTAT,R2 ; No, save status CALL SSTAT 20$: RETURN ; TRANSB: MOVB (R2)+,R1 ; Get byte BEQ 10$ ; Done ?? CALL PBYT ; Save it BR TRANSB 10$: RETURN ; ; SEND PAGE TOC command ; SENPTC::CALL (R4) ; get parameter MOV #0,R3 ; Default value CMP R3,#9. ; Check max BLOS 1$ ; OK ? JMP ERRHI 1$: TSTEQB $TOCSW,2$ ; TOC? JMP COMNT ; No, treat text as comment 2$: MOV R3,R5 ; Save param CALL LINFAK ; Get output buffer address in R3 MOV #IFTXT,R2 ; Get if text CALL IFOUT CALL $FRCND ; Get beginning of line MOV #TOCX,R1 ; TOC flag CALL PBYT MOV #1,R1 ; Output status CALL PBYT ; Set to output number MOV #72.,R4 ; Max number of chars 10$: CALL CCIN ; Get input CMPEQB R1,#CR,20$ ; End ?? CALL PBYT ; Save it SOB R4,10$ ; Till full 20$: CLR R1 ; Now chock it CALL PBYT ; Done MOV #EITXT,R2 ; Now end if text TSTNE BF.HED(R3),IFOUT; Header exists ? CALL IFOUT CLR R1 CALL PBYT ; Chock line RETURN IFOUT: TSTEQ R5,10$ ; No param or null ? 1$: MOVB (R2)+,R1 ; Get byte to trans BEQ 5$ ; Done ?? CALL PBYT ; Put into output BR 1$ 5$: MOV R5,R1 ; With number ADD #'0,R1 ; Convert to number CALL PBYT CLR R1 ; And null CALL PBYT ; to chock end 10$: RETURN .END