.title	WrtLet

	.includ	"b:global"

	sect	code

oWRi:	bitb	#xWRIN, mypriv+1	; May I write an entry?
	beq	nogo

	tst	thsgr
	beq	30$

	clr	r5
	cmp	#2, level
	bhi	10$

	mov	Found+2, r1
	call	GetAdr
	mov	(r1), r5

10$:	gos	ExtDP,	<thsgr,, r5> 	; Test for write-protectioness
	bcs	40$

	clr	out
	write	#T5
	gos	ListRc,	<out>
	clr	r1			; Marks an entry.
	clr	r0
	call	crelet

	rts	pc

30$:	write	#NGM
40$:	rts	pc

NOGO:	write	#dhir			; Say: "You're not allowed to.."
	rts	pc

NoNam:	write	#NoNamT
	rts	pc

oWrtL:	bitb	#xWRLE, mypriv+1
	beq	nogo

	repars	#2, #WRlP
	bcc	5$

3$:	jmp	999$

5$:	clr	r5
	call	fixlst			; r0 set to 2 by macro repars above!
	bcs	3$
	call	FixGrp
	mov	r1, r3
	mov	r0, r1
	asr	r0
	cmp	r0, Level
	bhis	10$
	mov	found(r1), r1
	call	GetAdr
	mov	(r1), r5
10$:	mov	r2, r0
	tst	r3
	beq	40$
	clr	r5
	
20$:	mov	r3, r1
	movb	(r1)+, r3
	mov	#FB3, r2
	mov	#1, (r2)+		; Nr of Receivers (Just one).
	movb	r3, (r2)
	incb	(r2)+
	movb	#'B, (r2)+
30$:	movb	(r1)+, (r2)+
	sob	r3, 30$
	mov	#FB3, r3

40$:	gos	ExtDP,	<r0, r3, r5>
	bcs	999$
	clr	out
	write	#T1
	gos	ListRc,	<out>
	clrb	tmpstr
	mov	#xBrev, r1
	gos	crelet
999$:	rts	pc


;+	COML - Comment on letter (or entry)
;
;-
oCOMl:	
	clr	-(sp)
	jsr	pc, anscom		; Comment on letter (or entry)
	rts	pc

;+	Prvans	- Private answer
;
;-
oPrvAn:
	gos	anscom <#-1>		; Private answer
	rts	pc

proc	anscom	<mode>

var	ext,	word
var	net,	word
var	ctt,	word
var	rece,	word

begin
	bitb	#xCOM, mypriv+1		; May I write comments?
	bne	3$
	jmp	nogo

3$:	clr	r4			; Will be the TEXT-record.
	clr	ext(r5)			; No distribution-mode yet.

4$:	mov	level, r3
	mov	#Found, r0

5$:	tst	(r0)+
	dec	r3
	bne	12$
	tst	r4
	bne	30$

	mov	oldl, r4		; Last read/written text #(physical)
	bne	30$
	mov	#WRcP, r3		; Default, assume commenting
	tst	mode(r5)		; Answering or commenting ?
	beq	10$			; if zero - commenting -> to 10$
	mov	#Whansw, r3		; Answering.

10$:	repars	#2, r3			; Ask for text to comment on or
	bcc	4$			;   write answer to.

	jmp	490$
	
12$:	mov	(r0), r1
	call	GetAdr
	mov	(r1), r2
	bmi	14$
	cmp	#1, r2
	beq	18$

	mov	r2, ext(r5)
	br	5$

14$:	tst	(r0)+
	dec	r3
	beq	25$
18$:	mov	r0, r2			; Save r0
	sub	#found, r0		; R0 shoud an index in found.
	call	GetNum
	mov	r1, FB2
	mov	r0, FB2+2
	mov	#FB2, r1
	mov	r1, r0
	call	cnvlet			; Make it into physical text #
	bcc	27$

25$:	jmp	490$			; Go to 490$ if no good

27$:	mov	r0, r4
	mov	r2, r0			; Restore r0.
	br	5$

30$:	push	r4			; r0 is physical text #
	gos	getrec,	<#2, r4, #FB4, #UnLock> ; Go get the text node
	cmp	(r1), #1		; A TEXT node? (If not -> screwed up)
	beq	32$
	write	#TxtERA			; Say the text is erased
	br	25$

32$:	bit	#xEXIN, 14(r1)		; EXTERNAL letter sent to KOM?
	beq	330$			; No.
	bit	#xBrev, 14(r1)
	bne	33$
	tst	mode(r5)		; Privat answer?
	beq	330$			; No => goto 330$
	
33$:	push	r1
	mov	r1, r4
	call	GtRece
	bcs	325$
	mov	r0, rece(r5)
	mov	r1, net(r5)
	mov	14(r4), r1
	bic	#xMulR!xEXIN, r1
	bis	#xKom!xEXT, r1
	pop	r1
	br	336$

325$:	cmp	(sp)+, (sp)+
	jmp	nogo
	
330$:	clr	net(r5)
	mov	12(r1), rece(r5)	; Creator
	tst	mode(r5)		; Private answer?
	bne	332$			; Yes! Then to 332$
	bit	#xBrev, 14(r1)		; Letter?
	beq	334$			; If not -> to 334$
	cmp	Me, rece(r5)		; Am I the creator?
	beq	334$			; If so -> Send it to the receiver(s)

332$:	bic	#xMulR, 14(r1)	
	br	336$

334$:	mov	16(r1), rece(r5)	; Send it to the receiver(s)

336$:	gos	ExtDP,	<rece(r5), net(r5), ext(r5)> ; Do the test
	bcs	490$

	mov	r1, r4			; r1 points to read record
	tst	mode(r5)		; Commenting or answering?
	beq	35$
	write	#pans			; "Private answer..."
	br	41$

35$:	bit	#xBrev, 14(r1)		; Commenting a letter?
	bne	40$			;
	write	#T3			; No, then write "Inl{gg.."
	br	41$

40$:	write	#T2			; Yes, write "Brev.."
41$:	mov	r4, r1			; Restore r1 (destroyed by write)
	tst	(r1)+			; Make r1 point to real text #
	clr	r0			; No formatting!
	call	deco32			; Output the text #
	write	#T0			; write "av"
	mov	r4, r1
	call	WrtFrm			; Destroys FB3
	call	PCRLF			; Do a new line

	clr	Out
	Write	#T7
	gos	ListRc,	<out>

; Commenting section

	pop	r0			; R0 will contain phys. text #
	mov	14(r4), r1
	bic	#xMulR, r1		; No multi-receiver!
	bis	#xKom, r1		; This is a comment!
	tst	mode(r5)		; Is this a private answer?
	beq	70$			; No, 70$
	bis	#xBrev, r1
70$:	clrb	tmpstr
	call	crelet
490$:	ret

;+
; GtRece gets all recievers to a comment of a letter pointed
;  to by r1
; Call:		r1 => Point out TEXT nod in memory
;
; Return:	r0 => Fhysical reciver == N{tperson
;		r1 => Pointer to reciverlist in FB3
;
; Destrys FB1, FB4 (list) and TmpStr
;-

Proc 	GtRece
	Var	flag, 	word
	Var	NrOfLi,	word
	Var	MessId,	word
	Var	LastP,	word

begin
	push	<r2, r3, r4>
	clr	flag(r5)		; Reply-To not found (yet).
	clr	lastp(r5)		; Last line was not a receiver.
	gos	opnlin,	<#FB1>
	mov	r3, r1
	mov	r2, NrOfLi(r5)
	beq	200$
	clr	FB4

20$:	gos	GetLin,	<#FB1>
	mov	#TmpStr, r2
	clr	r0
	bisb	(r2)+, r0
	beq	70$
	movb	(r2)+, r4

	cmpb	#'+, r4
	bne	25$
	tst	LastP(r5)		; Was last line a receiver?
	beq	70$			; No - Try next line.
	inc	FB4			; Yes- Inc nr of recievers.
	br	40$			; Get next receiver.

25$:	tst	flag(r5)
	bne	100$			; Nothing more to get!

	cmp	#'A, r4
	beq	30$			; Aha, a From field.
	cmpb	#'G, r4
	beq	29$			; Aha, a Reply-To field.

	clr	LastP(r5)		; No receiver found this time.
	br	70$			; Try next field.

29$:	dec	flag(r5)		; Reply-To found!

30$:	dec	LastP(r5)		; We are saving receivers!
	mov	#FB4, r3
	mov	#1, (r3)+		; Just one recever found yet!
	mov	#'B, r4

40$:	dec	r0
	beq	70$
	movb	r0, (r3)		; Length of receiver.
	incb	(r3)+
	movb	r4, (r3)+
50$:	movb	(r2)+, (r3)+
	cmp	#FB4+1000, r3
	blos	115$
	sob	r0, 50$

70$:	dec	NrOfLi(r5)
	bgt	20$

100$:	br	130$

115$:	Write	#ToLng
	br	200$

130$:	mov	#LibInf, r1
	call	GetAdr
	mov	16(r1), r0		; N{tperson
	mov	#FB4, r1

190$:	tst	(pc)+
200$:	sec
	pop	<r4, r3, r2>
	ret

.rem &

foobar

;+	WRPTST - test for write-protectioness
;
; Input: r0,	(logical) meeting # of meeting to be tested
;	 r1,	Pointer to file buffer to use.
;
; Returns: C set if write-protected
;
; All registers are preserved.
; The RESLIB may get remapped.
;-
wrptst:
	push	<r0, r1, r2>		; Isn't there a MACRO for these things
					; (pushing many registers i mean)
	bit	#AdmPrv!AbsPrv, KSW	; No need to check if we're privved
	bne	10$			; So, goto 10$ and return
	mov	r1, r2
	mov	#GRPLST, r1
	call	findcm
					; What if R0 is 0 ?
	beq	10$			; Pretend all went well... (if so)
	cmp	rPri1-rStr(r0), #1	; A person?
	beq	10$			; Yes - to 10$

	gos	getrec <#1, rArg-rStr(r0), r2, #unlock>
	cmp	Me, 10(r1)		; If I'm the organizer - OK to write!
	beq	10$
	bit	#xWP, 16(r1)		; Test if it IS write protected
	beq	10$
	write	#prtmee			; Say: "writeprotected!!!!" (haha)
	br	20$
10$:	tst	(pc)+
20$:	sec
	pop	<r2, r1, r0>
	rts	pc	

; &

; +
; ExtDP  -  test for write-protectioness, and external
; distribution (and puts it to memory).
;
; Returns carry set if something went wrong
; distribution pointers in R0/R1.
; -

proc	ExtDP,	<Grp, Net, ExtP>

Var	DstFlg,	word
var	count,	word
Var	nr,	word
var	DstBlk,	word
var	MtgBlk,	word
var	PrfChr,	word

begin
	push	<r4, r3, r2, r1, r0>
	clr	DstFlg(r5)
	mov	Grp(r5), r0	
	mov	#GRPLST, r1
	call	findcm
	tst	r0
	bne	10$

	Write	#GruBo
	jmp	4711$

10$:	gos	getrec <#1, rArg-rStr(r0), #FB1, #unlock>
	mov	r1, r2
	cmp	(r2), #3		; Typ of group?
	beq	20$			; Person.
	blo	70$			; NetPerson.
					; Meeting.
	bit	#xExDs, 16(r2)
	beq	15$
	dec	DstFlg(r5)
15$:	bit	#AdmPrv!AbsPrv, KSW	; No need to check if we're privved
	bne	50$			; So, goto 10$ and return
	cmp	Me, 10(r2)		; If I'm the organizer - OK to write!
	beq	50$
	bit	#xWP, 16(r2)		; Test if it IS write protected
	beq	50$
	write	#prtmee			; Say: "writeprotected!!!!" (haha)
	jmp	4711$

20$:	bit	#xExD, 16(r2)
	beq	25$
	dec	DstFlg(r5)

25$:	mov	r2, r1
	add	#110, r1		; "Note on the door"
	clr	r0
	bis	(r1), r0
	bis	-(r1), r0
	beq	50$
	
	mov	#FB3, r0
	call	CnvLet
	bcs	50$
	mov	r0, r1
	mov	#6, r0			; Magic!
	call	Disply			; Show the "note on the door".
	call	ctrlo

50$:	cmp	#4, ExtP(r5)
	beq	90$			; Local distribution

	cmp	#2, ExtP(r5)
	beq	55$

	tst	DstFlg(r5)
	beq	90$	
	mov	142(r2), nr(r5)
	beq	90$
	br	60$

55$:	mov	142(r2), nr(r5)
	bne	60$

	Write	#SkDi
	jmp	4711$

60$:	mov	144(r2), DstBlk(r5)
	br	100$

	; Text to a NetPerson.

70$:	bit	#NetNam, USW		; Got to have an internet name...
	bne	75$

	Write	#NoNamT
	jmp	4711$

75$:	bit	#AdmPrv!AbsPrv, KSW
	bne	90$			; Always Ok!!!

	bit	#xNWP!xNCl, 16(r2)
	bne	80$

	bit	MyNtRt, 36(r2)
	bne	90$

80$:	Write	#DHIR
	jmp	4711$

90$:	clr	nr(r5)
	clr	DstBlk(r5)

100$:	mov	#OrgTxt, r4
	clr	(r4)+
	clr	(r4)+
	mov	#1, (r4)+		; # of receivers this far.
	mov	Grp(r5), (r4)+		; Receiver # one.
	mov	r4, r3
	mov	r3, (r4)+		; Pointer to next.
	mov	Net(r5), r1
	beq	106$

	mov	(r1)+, r2
	mov	r2, (r4)+
	beq	108$
104$:	movb	(r1)+, r0
	movb	r0, (r4)+
105$:	movb	(r1)+, (r4)+
	sob	r0, 105$
	inc	r4
	bic	#1, r4			; Make r4 even!
	sob	r2, 104$
	br	108$	

106$:	clr	(r4)+			; Nr of headers

108$:	clr	FB2-2

110$:	mov	DstBlk(r5), r0
	beq	200$
	gos	TryRec,	<#1, r0, #FB1, #Unlock>
	mov	2(r1), DstBlk(r5)
	mov	#20., count(r5)
	mov	r1, r2
	add	#10, r2

130$:	gos	WrToP,	<(r2), #Fb2, #False>
	bcc	135$

	cmp	(r2)+, (r2)+		; Access failur...
	br	170$			; => Skip him/her/it...

135$:	inc	DstBuf
	sub	r4, (r3)		; Next pointer for previous
	neg	(r3)			; It's relative!
	mov	(r2)+, (r4)+		; receiver
	mov	r4, r3
	mov	r3, (r4)+		; next
	clr	(r4)+			; # of headers.

	mov	(r2)+, r0
	beq	170$

	mov	#'B, PrfChr(r5)		; A To-field.

140$:	gos	TryRec,	<#1, r0, #FB2, #Unlock>
	mov	2(r1), MtgBlk(r5)
	add	#14, r1
	movb	(r1)+, r0
	beq	160$
	inc	2(r3)			; Nr of headers
	movb	r0, (r4)
	incb	(r4)
	tst	MtgBlk(r5)
	beq	148$
	incb	(r4)			; Make room for a ",".
148$:	inc	r4
	movb	PrfChr(r5), (r4)+
150$:	movb	(r1)+, (r4)+
	sob	r0, 150$
	mov	#'+, PrfChr(r5)
160$:	mov	MtgBlk(r5), r0
	beq	165$
	movb	#',, (r4)+
	inc	r4
	bic	#1, r4
	br	140$

165$:	inc	r4
	bic	#1, r4

170$:	tst	(r2)+
	dec	nr(r5)
	beq	200$
	dec	count(r5)
	bne	130$
	br	110$

200$:	sub	r4, (r3)		; Next pointer for last.
	neg	(r3)			; It's relative!
	mov	r4, EoDPos		; 1'st free position.
	tst	(pc)+
4711$:	sec
	pop	<r0, r1, r2, r3, r4>
	ret

Proc	ListRc,	<Lft>

var	lft2,	word

begin
	push	<r2, r3, r4>
	mov	#DstBuf, r1
	mov	(r1)+, r2
	beq	999$
	
10$:	mov	Lft(r5), out
	mov	(r1)+, r0
	call	PrtNam
	mov	r1, r4
	add	(r1)+, r4
	mov	(r1)+, r3
	beq	100$

	push	r1
	Write	#KoSp
	pop	r1
	mov	Out, Lft2(r5)	

30$:	movb	(r1)+, r0
	dec	r0
	inc	r1
	call	PrintN
50$:	add	r0, r1
	inc	r1
	bic	#1, r1
	dec	r3
	beq	100$
	call	pcrlf
	mov	Lft2(r5), r0
	call	SpcOut
	br	30$

100$:	mov	r4, r1
	beq	140$
	dec	r2
	beq	140$
	mov	#',, r0
	call	ttyout
	call	pcrlf
	mov	Lft(r5), r0
	call	SpcOut
	br	10$

140$:	call	pcrlf

999$:	pop	<r4, r3, r2>
	ret

Text	GruBo,	<"Mottagaren {r utpl}nad."<CR><Lf><Cr><Lf>>
Text	subjec,	<"Subject: ">
Text	T0,	<" av ">
Text	T1,	<"Brev till ">
Text	T2,	<"Kommentar till brev ">
Text	T3,	<"Kommentar till inl{gg ">
Text	T5,	<"Inl{gg till ">
Text	T6,	<"Kommentar till ">
Text	T7,	<"Mottagare: ">
Text	KToNxt,	<<Cr><Lf>"               ">
Text	WRlP,	<"Till vem vill du skicka BREVet">
Text	WRcP,	<"Vilket inl{gg vill du kommentera">
Text	Whansw,	<"Vilken text vill du svara p}">
Text	pans,	<"Privat svar p} text ">
Text	prtmee,	<"M|tet {r skrivskyddat."<cr><lf><cr><lf>>
Text	SkDi,	<"Gruppen saknar extern distrubution."<Cr><Lf><Cr><Lf>>
Text	ToLng,	<<Cr><Lf><Cr><Lf>"F|r l}ngt mottagarf{lt"<Cr><Lf><Cr><Lf>>

NoNamT: .byte	20$-10$
10$:	.ascii	"Du m}ste s{tta ett internetnamn f|r att f} g|ra detta."
	.ascii	<Cr><Lf><Cr><Lf>
20$:

	.even
	.end