.title	Disply

	.includ	'b:global'

	maxhdr	= 60.

	sect	code

;++
; disply skriver ut ett inl{gg och s{tter oldl.
; argument	r1 => fysiskt inl{ggs record
;		r0 => whattodoword (se nedan)
;		      byte 1 (funktion vid bit satt)
;			bit 0 :	visa inte avs{ndaren
;			bit 1 :	visa inte mottagaren
;			bit 2 :	visa inte "kommentarer"
;			bit 3 : ingen streck-rad efter {renderaden
;			bit 4 : utan text
;			bit 5 : visa ALLA n{tverksparametrar.
;			bit 6 : avsluta inte med cr2lf.
;			bit 7 : list format.
;		      byte 2 = antal rader som ska visas (0 = alla)
;
; obs, f|rst|r fb4 och fb3 och tmpstr.
;
; dsply2 g|r samma sak men fodrar att r1 ska peka
; in i en filbuffert vars address ligger i curblk.
; obs, s{tter ej oldl. blocket kan f|rst|ras av disply.
;--

dsply2:	push	<r0,r1,r3>
	mov	r0,r3
	br	dsply

disply:	push	<r0, r1, r3>
	mov	r1, oldl
	mov	#fb4, curblk
	mov	r0, r3
	gos	getrec,	<#2, r1, #fb4, #unlock>
dsply:	bis	#utmon, ksw
	push	<r2, r4, r5>
	mov	r1, r5

	cmp	#1, (r1)
	beq	2$

	clr	comttt			; Texten {r utpl}nad!
	clr	nxtcom
	write	#txtera
1$:	jmp	999$

2$:	mov	32(r5), comttt		; kommentar till denna text
	mov	26(r5), nxtcom		; n{sta komentar i tr{det
 
	tstb	r3
	bpl	3$

	call	dsplst
	jmp	790$

3$:	bit	#1, r3
	bne	5$
	write	#pate
	mov	r5, r1
	tst	(r1)+
	clr	r0
	call	deco32
	write	#paav
	mov	r5, r1
	call	wrtfrm			; Returns Date in r0
	write	#space
	mov	r5, r1
	add	#6, r1
	call	prtdat

5$:	bit	#2,r3
	bne	10$

	call	wrecei			; WriteReceivers
	bcs	39$

10$:	call	pcrlf
	bcs	39$
1001$:	bit	#4,r3
	bne	40$
	mov	24(r5),r2		; Kommentar till?
	beq	40$			; No!
	Write	#KOTO
	bcs	3999$
	write	#PATE
	gos	getrec	<#2, r2, #FB3, #Unlock>
	mov	r1,r2
	clr	r0
	tst	(r1)+
	call	deco32
	Write	#PAAV
	mov	r2, r1
	call	wrtfrm
	call	pcrlf
39$:	bcc	40$
3999$:	jmp	999$

40$:	bit	#xExt, 14(r5)
	beq	43$
	
	bit	#xBl, MyFlag
	beq	42$
	mov	#68., r0
	mov	#'-, r1
	call	string
42$:	call	pcrlf
	bcs	380$
	clr	r0
	bit	#40, r3
	beq	42010$
	bis	#2, r0
42010$:	mov	r5, r1
	gos	DspHdr,	<r0>
	bcs	380$

43$:	bit	#20,r3
	beq	45$
	jmp	800$

45$:	gos	TxtOut,	<20(r5), 22(r5), #FB3>
	
380$:	Write	#Pate
	mov	r5,r1
	tst	(r1)+
	clr	r0
	call	deco32
	mov	#'),r0
	call	ttyout
	write	#SPACE
	mov	#'-, r1
	mov	#18., r0
	call	string
	mov	14(r5), r4
	mov	32(r5),r2
	beq	790$

	clr	r5			; Antal kommentarer
400$:	gos	TryRec,	<#2, r2, CurBlk, #Unlock>
	mov	r1,r2
	bit	#xSAC,MyFlag
	beq	450$
	tst	r5
	bne	410$
405$:	mov	#CRP,r1
	br	420$
410$:	mov	#CRSP,r1
420$:	call	strout	
	bcs	999$
	clr	r0
	mov	r2,r1
	tst	(r1)+
	call	deco32
	Write	#PAAV
	mov	r2, r1
	call	wrtfrm
450$:	inc	r5
	mov	26(r2),r2
	bne	400$

	bit	#xSAC,MyFlag
	beq	460$
	mov	#SLP,r1
	br	470$
460$:	Write	#TABP
	mov	r5,r1
	clr	r0
	call	deco16
	dec	r5
	bne	465$
	mov	#KOEN, r1
	br	470$
465$:	mov	#KOER, r1
470$:	call	strout

790$:	bit	#100, r3
	bne	800$
	call	pcrlf
800$:	call	pcrlf
999$:	pop	<r5,r4,r2,r3,r1,r0>
	bcc	1000$
	call	pcrlf
	sec
1000$:	bic	#UtmOn,KSW	
	rts	pc

Proc	GetLin,	<buf>
	Var	limit, word
	begin
	push	<r0, r2, r3>
	mov	buf(r5), limit(r5)
	add	#1000, limit(r5)
	mov	#TmpStr, r2
	call	GetChr	
	movb	r0, (r2)+
	mov	r0, r3
	beq	99$
10$:	call	GetChr
	movb	r0, (r2)+
	sob	r3, 10$
	br	99$

	GetChr	= .

	cmp	r1, limit(r5)
	blo	50$
	mov	buf(r5), r1
	gos	Get,	<#3,,r1,#1,#Unlock>	; Get next block.
50$:	clr	r0
	bisb	(r1)+, r0
	rts	pc	

99$:	pop	<r3, r2, r0>
	ret

Proc	GetWrd,	<buf>
	begin
	push	r2
	mov	buf(r5), r2
	add	#1000, r2
	cmp	r1, r2
	blo	50$
	mov	buf(r5), r1
	gos	Get,	<#3,,r1,#1,#Unlock>	; Get next block.
50$:	mov	(r1)+, r0
	pop	r2
	ret


proc	TxtOut,	<Blk, Pos, Buf>

var	lines,	word

begin
	push	<r2, r3, r4>
	mov	Buf(r5), r1
	gos	get,	<#3, Blk(r5), r1, #1, #Unlock>
	add	Pos(r5),r1		; Line (down)counter
	cmp	#-1, (r1)+
	beq	48$

42$:	Write	#Ilfr
	jmp	377$

48$:	gos	GetWrd,	<Buf(r5)>
	cmp	#1, r0
	bne	42$

	gos	GetWrd,	<Buf(r5)>
	mov	r0, r2		; # of lines!
	mov	r0, lines(r5)
	mov	r3,r4
	clrb	r4
	swab	r4			; # of lines to be printed
	beq	50$
	cmp	r2,r4
	blos	50$
	mov	r4,r2

50$:	gos	GetLin,	<Buf(r5)>
	call	OutN
	bcs	55$
	gos	PrCrLf,	<Lines(r5), r2>
	bcs	999$
55$:	bit	#10, r3			; Should we print a bar line ?
	bne	70$			; No! skip it.
	bis	#10, r3			; Not again.
	push	<r0, r1>
	bit	#xBl, MyFlag
	beq	60$
	mov	#68., r0
	mov	#'-, r1
	call	string
60$:	pop	<r1, r0>
	gos	PrCrLf,	<Lines(r5), r2>
	bcs	999$

70$:	sob	r2,50$

377$:	call	pcrlf
999$:	pop	<r4, r3, r2>
	ret


OutN:	push	r1
	mov	#TmpStr, r1
	movb	(r1)+, r0
	beq	7$
	cmpb	#'@, (r1)		; [r denna rad ett filnamn?
	beq	10$
5$:	call	PrintN			; Skriv ut raden (eller delen av raden)
7$:	clc
	br	99$

10$:	bit	#xFil, MyFlag
	beq	5$
	inc	r1
	dec	r0
	beq	7$
	call	DispFi
	sec
99$:	pop	r1
	rts	pc

;+
; DspLst skriver ut texten i list format.
; Anrop:	r1 => TEXT-noden i minnet (fil 2)
; F|rst|r TmpStr
;-

DspLst:	tst	(r1)+			; Presentation i list-format.
	mov	#11., r0
	call	deco32
	Write	#csq
	mov	r5, r0
	mov	#FB3-2, r1
	clr	(r1)+
	push	r3
	call	fixhdr
	pop	r3
	mov	#TmpStr, r1
	cmpb	(r1), #maxhdr
	blos	10$
	movb	#maxhdr, (r1)
10$:	call	strout
	mov	#'", r0
	call	ttyout
	rts	pc

proc	opnlin,	<buf>

begin
	push	r0
	mov	buf(r5), r3
	mov	42(r1), r2
	gos	Get,	<#3, 40(r1), r3, #1, #UnLock>
	mov	r3, r1
	add	r2, r1
	mov	#TmpStr, r3
	mov	#8., r2
10$:	gos	GetWrd,	<buf(r5)>
	mov	r0, (r3)+
	sob	r2, 10$
	gos	GetWrd,	<buf(r5)>
	mov	r0, r2		; Nr of lines given.
	mov	r1, r3
	mov	#TmpStr, r1
	cmp	#-1, (r1)
	beq	30$

20$:	Write	#IlEf
	clr	r2
	br	99$

30$:	cmp	#2, 2(r1)
	bne	20$

99$:	pop	r0
	ret

;+
; WrtFrm skriver ut avs{ndaren. Om n{tperson annv{nds n{tadress.
; Anrop:	r1, Pekare till text i minnet
; F|rst|r FB3
;-

wrtfrm:	push	r0
	bit	#xExIn, 14(r1)
	bne	10$
	mov	12(r1), r0
	call	prtnam
	pop	r0
	rts	pc

10$:	push	<r1, r2, r3>
	gos	opnlin,	<#FB3>
	tst	r2
	beq	99$
	call	gtln
	mov	#TmpStr, r1
	clr	r0
	bisb	(r1)+, r0
	dec	r0
	beq	99$
	tstb	(r1)+
	call	printN
	mov	#DspDat, r0

99$:	pop	<r3, r2, r1, r0>
	rts	pc

;+
; DspHdr shows headers to a text
; call	r1, pointer to TEXT-record in memory.
;	SW, Bit 1 = * Reserved *
;	    Bit 2 = Show all headers
;-

proc	DspHdr,	<SW>

var	flag,	word
var	nr,	word

begin
	push	<r3, r4>

	bit	#2, SW(r5)
	bne	10$

	tst	MyHdrW
	beq	99$

10$:	clr	flag(r5)		; No previous line printed.
	mov	r1, r4

	gos	opnlin,	<#FB3>
	inc	r2
	mov	r2, nr(r5)

50$:	dec	nr(r5)
	ble	80$
	call	gtln
	clr	r2
	bisb	(r1)+, r2
	beq	50$
	cmpb	(r1), #'+
	bne	55$

	tst	flag(r5)
	beq	50$			; No prevous line to be continued..
	inc	r1
	mov	r4, r0
	call	SpcOut
	br	70$

55$:	clr	r4
	bisb	(r1)+, r4
	cmpb	r4, #'Z
	bne	60$

	bit	#2, SW(r5)
	bne	56$
	bit	#100000, MyHdrW		; Do we want to see this header?
	beq	57$			; No!

56$:	clr	r4
	br	70$

57$:	clr	flag(r5)			; Skip this header
	br	50$

60$:	sub	#'A, r4
	asl	r4
	asl	r4
62$:	bit	#2, SW(r5)
	bne	64$
	bit	HdrTbl(r4), MyHdrW	; Do we want to see this header?
	beq	57$			; No, skip it...
64$:	mov	HdrTbl+2(r4), r1
	clr	r4
	bisb	(r1), r4
	call	strout
65$:	mov	#Tmpstr+2, r1

70$:	inc	flag(r5)
	dec	r2
	beq	75$
	mov	r2, r0
	call	PrintN
75$:	call	pcrlf
	bcc	50$
	br	99$

80$:
99$:	pop	<r4, r3>
	ret

gtln:	mov	r3, r1
	gos	GetLin,	<#FB3>
	mov	r1, r3
	mov	#TmpStr, r1
	rts	pc

;+
; wrecei writes all receivers (in KOM) of the text.
; Call	R5 = Pointer to TEXT in memeory
;-

wrecei:	push	<r4, r3, r2, r1>
	clr	r3
	mov	36(r5), r4
	mov	r5, r2
;	bit	#xEXT, 14(r5)
;	beq	10$
;	bit	#xEXIN, 14(r5)
;	beq	18$			; Write only outher receivers.

10$:	tst	r3			; Has the header been written?
	bne	15$			; Yes!
	call	pcrlf
	bcs	99$
	mov	#MOTTAG, r1
	bisb	(r1), r3
	call	strout
	br	17$

15$:	mov	#',, r0
	call	ttyout
	call	pcrlf
	bcs	99$
	mov	r3, r0
	call	SpcOut

17$:	mov	16(r2), r0
	call	prtnam	
	mov	r2, r0
	add	#46, r0
	tst	(r0)
	beq	18$
	tst	-(r0)
	beq	18$
	Write	#MOTDAT
	mov	r0, r1
	call	PrtDat

18$:	mov	36(r2), r2
	beq	50$
	gos	TryRec,	<#2, r2, CurBlk, #UnLock>
20$:	mov	r1, r2
	cmp	36(r2), r4	; End detected?
	bne 	10$		; Yes! - Exit.

50$:

99$:	pop	<r1, r2, r3, r4>
	rts	pc

ReadFi:	Repars	#2, #FilT
	bcs	999$
	mov	Strs+4, r0
	mov	Strs+2, r1
	sub	r1, r0
	dec	r0
	call	DispFi
	call	pcrlf

999$:	rts	pc


;+
; DispFi "Disply file" Skriver ut en fil p} sk{rmen
; Anrop:	r0 	=> L{ngden av filnamnet
;		r1	=> Position.
; Skapar en filbuffert p} stacken.
;-

DispFi:	push	<r0,r1,r2,r3,r4,r5>
	mov	r1, r2
	call	clrfqb
	call	clrxrb
	mov	r0, (r1)+
	mov	r0, (r1)+
	mov	r2, (r1)+
	.FSS
	tstb	Firqb
	beq	10$
	Write	#FFN
	br	999$
10$:	movb	#OPNFQ, Firqb+Fqfun
	movb	#13*2, Firqb+FqFil
	CALFIP
	call	FilErr
	bcs	999$
	mov	Firqb+FqSiz, r3
	beq	50$
	sub	#1000, sp
	mov	sp, r5
20$:	gos	Get,	<#13,,r5, #1,>
	mov	r5,r1
	mov	#1000, r0
	call	Print
	bcs	40$
	sob	r3,20$
40$:	add	#1000, sp
50$:	call	clrfqb
	movb	#CLSFQ, Firqb+FqFun
	movb	#13*2, Firqb+FqFil
	CALFIP
	tst	r3
	beq	1000$
	sec
	br	1000$

999$:	clc
1000$:	pop	<r5,r4,r3,r2,r1,r0>
	rts	pc


Text	csq,	</: "/>
Text	FFN,	<"Felaktigt filnamn."<CR><LF>>
Text	FilT,	<"Filnamn">
Text	MOTTAG,	<"Mottagare: ">
Text	MOTDAT,	<",  Mottaget: ">
Text	PATE,	<"(Text ">
Text	PAAV,	<") av ">
text	KOTO,	<"Kommentar till ">
Text	CRP,	<<CR><LF>"(Kommentar i (text ">
Text	CRSP,	<<CR><LF>"             (text ">
Text	SLP,	<")">
Text	TABP,	<<11>"(">
Text	KOER,	<" kommentarer)">
Text	KOEN,	<" kommentar)">
Text	TxtERa,	<"Texten {r utpl}nad!"<CR><LF><LF>>
Text	IlFr,	<<Cr><Lf>"%Felaktigt textformat."<Cr><Lf>>
Text	IlEf,	<"%Felaktigt EXTERN-format."<Cr><Lf>>

Text	tFrom,	<"From: ">
Text	tTo,	<"To: ">
Text	tSend,	<"Sender: ">
Text	tBcc	<"Bcc: ">
Text	tDate,	<"Date: ">
Text	tId,	<"Message-Id: ">
Text	tRep,	<"Reply-To: ">
Text	tRepTo,	<"In-Reply-To: ">
Text	tRecei,	<"Receiver: ">
Text	tCc,	<"Cc: ">
Text	tRtPth,	<"Return-Path: ">
Text	tStat,	<"Status: ">
Text	tRefer,	<"References: ">
Text	tKeyW,	<"Keywords: ">
Text	tOrg,	<"Organization: ">
Text	tXref,	<"Xref: ">
Text	tFolT,	<"Followup-To: ">

	.even
HdrTbl:	.word	20000,	tFrom		; 'A'
	.word	40000,	tTo		; 'B'
	.word	20000,	tSend		; 'C'
	.word	10000,	tBcc		; 'D'
	.word	4000,	tDate		; 'E'
	.word	400,	tId		; 'F'
	.word	1000,	tRep		; 'G'
	.word	2000,	tRepTo		; 'H'
	.word	1,	tRecei		; 'I'
	.word	10000,	tCc		; 'J'
	.word	2,	tRtPth		; 'K'
	.word	4,	tStat		; 'L'
	.word	10,	tRefer		; 'M'
	.word	20,	tKeyW		; 'N'
	.word	40,	tOrg		; 'O'
	.word	100,	0		; 'P'
	.word	200,	tFolT		; 'Q'

	.end