.title	DBSCHK

	.inclu	"b:global"

	APR1	= 1
	APR2	= 2
	APR3	= 3
	APR4	= 4
	APR5	= 5

	xDBVer	= 50.			; Version # for database.

	GrpCkP	= 1
	TxtCkP	= 2
	
.macro	Trace	File, Rec, Typ
	gos	PutTrc,	<File, rec, Typ>
.endm

.macro	ErrTrc	Err
	gos	TrcErr,	<Err>
.endm

.Macro	Makc,Label,Nr,Str,Nxt,Typ,Arg,Pri1,Pri2,Linkp,Lnkpri
	.if nb Lnkpri
	  .word	LnkPri
	  .word	Linkp
	.iff
	  .if nb Linkp
	    .Word	Linkp
	  .endc
	.endc
Label:	.Word	Nr
	.Word	Nxt
	.word	Arg
	.Word	Pri1
	.Word	Pri2
	.Byte	Typ
	.Byte	20$-10$
10$:	.Ascii	Str
20$:	.Even
.Endm

	sect	code

INIT::	.ttnch				; No Echo
	mov 	#^RDBS, firqb+fqnam1
	mov 	#^RCHK, firqb+fqnam1+2
	.name				; Set work name
	clr	Me
	mov	#LinLen-2, MaxLin
	mov	#-1, Line
	clr	PTerm			; Default term-typ (dummy crt)
	clrb	xrb+xrci
	.postn
	mov	#Width,r0
	clr	(r0)			; ?
	movb	xrb,(r0)
	decb	(r0)
	movb	firqb+fqjob, r0
	asr	r0
	mov	r0, Job
	write	#DBSTXT			; Write a friendly phrase with version.
	errprt	#0
	write	#CRLF

	mov	#xSM!xELIN!xBL!xExp, MyFlags
	mov	#UnProm, Stat
	clr	KSW
	movb	#UU.SYS,Firqb+fqfun
	clr	firqb+4
	.UUO
	mov	firqb+26, PPN
	movb	Firqb+5, TERM


OPFIL::	mov	#EOFS,r2		; Open files
	mov	#<EOFS-Files>/2, r0	; Number of files * 2

10$:	mov	#firqb+fqfun, r1
	movb	#opnfq, (r1)+
	mov	r0, (r1)+		; Unit number * 2
	mov	KOMPPN, (r1)+
	mov	#^RKOM, (r1)+
	mov	-(r2), (r1)+
	mov	-(r2), (r1)+
	mov	#8192.+32768., firqb+fqmode ; Open files ReadOnly
	mov	KOMDEV, firqb+fqdev
	mov	KOMDVN, firqb+fqdevn
	calfip
	jsr	pc, @#error

	mov	Firqb+FqSiz, r3		; Nr of blocs.
	mov	NClus-2(r0), r4		; Nr records in each block.
	mov	r3, FilSiz-2(r0)
	mul	r4, r3
	mov	r3, MaxRec-2(r0)	; Nr records in File.

	dec	r0
	sob	r0, 10$
	write	#CRLF

	mov	#2,r2
	gos	Get, <#1, r2, #FB1, #1,>	; Get INFO-block
	add	#1, NrAcc
	adc	NrAcc+2
	cmp	#xDBVer, @#FB1+32	; Right DATABASE Version
	beq	20$
	iot

20$:	mov	FB1+30, NrGrp
	mov	FB1+22, TxtHig
	mov	FB1+24, TxtHig+2
	mov	FB1+110, HshSiz		; # of entrys in hash-table.
	mov	FB1+112, HshEnd

1000$:	mov	#stack, sp
	mov	#qmprm, stat

	PARSER	#WhtLst, #-1, #WhtTxt
	call	pcr2lf
	mov	Level, r0
	beq	1020$

	clr	WhtWrd
	mov	#Found, r1

1010$:	bis	@(r1)+, WhtWrd
	sob	r0, 1010$

1020$:	PARSER	#LogLst, #-1, #LogFT
	call	pcr2lf
	mov	#-1, Line
	tst	level
	beq	CHKGRP
	mov	#PStr1, r1
	call	OpnFil
	bis	#UtmOn, KSW

CHKGRP::	

	bit	#GrpCkP, WhtWrd
	bne	5$

	jmp	CHTEXT

5$:	Write	#Chk1T
	call	CurDaT

	clr	Errors
	clr	FB1-2			; File buffert for file 4
	clr	FB2-2			; File 1
	clr	FB3-2			; File 1
	clr	FB4-2			; File 2
	clr	FBA-2			; File 5 (Log/Fys)
	clr	FBB-2			; File 1
	clr	FBC-2			; File 2
	clr	FBD-2			; File 4
	tst	NrGrp
	bne	20$
	br	200$

10$:	dec	NrGrp
	beq	200$
20$:	clr	TrcLvl
	inc	ThisGr
	gos	TryRec,	<#4, ThisGr, #FB1,>
	add	#1, NrAcc
	adc	NrAcc+2
	mov	r1, ThisNa
	add	#6, ThisNa
	mov	r1, r4
	mov	(r1), r2
	beq	10$			; OPERSON

	cmp	#1, r2
	bne	30$
	inc	NrPNa
	br	100$

30$:	cmp	#2, r2
	bne	40$
	inc	NrMNa
	br	100$

40$:	cmp	#4, r2
	bne	50$
	inc	NrTTy
	br	10$

50$:	cmp	#10, r2
	bne	90$

	inc	NrNPN
	br	100$

90$:	ErrTrc	#Err01
	br	10$

100$:	gos	ChkGrZ,	<2(r4), 4(r4), r2>
	br	10$

200$:	gos	Get,	<#1, #1, #FB2, #1,>
	add	#1, NrAcc
	adc	NrAcc+2
	mov	FB2+2, r2
	beq	400$
	clr	TrcLvl
	clr	ThisGr

210$:	clr	TrcLvl
	Trace	#1, r2, #0
	gos	mark1,	<r2, #True>
	gos	TryRc1,	<r2, #FB2>
	bcs	400$
	tst	(r1)+
	beq	220$

	ErrTrc	#Err45
	br	400$

220$:	inc	NrFre1
	mov	(r1), r2
	bne	210$

400$:	call	pcr2lf
	Write	#DubT
	call	pcr2lf
	mov	#9., r5
	clr	r3

410$:	gos	Mark1,	<r5, #False>
	bcs	440$
	cmp	r3, #10
	beq	420$
	tst	r3
	beq	430$
	Write	#CSpT
	br	430$

420$:	clr	r3
	call	pcrlf

430$:	inc	r3
	mov	r5, r1
	clr	r0
	call	deco16
440$:	inc	r5
	cmp	MaxRec, r5
	bhis	410$

CHTEXT::

	bit	#TxtCkP, WhtWrd
	bne	10$

	jmp	Result

10$:	call	pcr2lf
	Write	#Chk2T
	call	CurDaT	
	clr	FB1-2			; File 5
	clr	FB2-2			; File 5
	clr	FB3-2			; File 5
	clr	FB4-2			; File 5
	clr	FBA-2			; File 2
	clr	FBB-2			; File 2
	clr	FBC-2			; File 2
	clr	FBD-2			; File 2
	
	clr	ThisGr

	clr	r3
	clr	r4

100$:	clr	TrcLvl
	add	#1, r3
	adc	r4
	cmp	r4, TxtHig+2
	bhi	400$
	blo	110$
	cmp	r3, TxtHig
	bhi	400$

110$:	Trace	#5, r3, r4
	gos	T2Rec5,	<r3, r4>
	bcs	100$

	mov	(r1), r0
	beq	100$
	Trace	#2, r0, #1
	mov	r0, ThisTx
	gos	Mark2,	<r0, #True>
	gos	T2Rec2,	<r0>
	bcs	100$

	cmp	#1, (r1)
	beq	140$

	ErrTrc	#Err14
	br	100$

140$:	inc	NrTxt
	cmp	r3, 2(r1)
	bne	150$
	cmp	r4, 4(r1)
	beq	160$

150$:	ErrTrc	#Err15
	br	100$

160$:	mov	#TxtCop, r2
	mov	#20, r0
170$:	mov	(r1)+, (r2)+		; Save Current TEXT-rekord.
	sob	r0, 170$
	mov	#TxtCop, r2

	cmp	20(r2), MaxRec+4
	blos	180$

	ErrTrc	#Err46

180$:	bit	xEXT, 14(r2)
	beq	190$
	cmp	6(r2), MaxRec+4
	blos	190$

	ErrTrc	#Err47

190$:;	gos	ChkTCT			; Check The Commented Text.
	gos	ChkCTL			; Check Comments on This Level.
	gos	ChkCTT			; Check Comments to This Text.
	gos	ChkMuR			; Check Multi Receivers.
	br	100$
	

400$:	gos	Get,	<#2, #1, #FBA, #1,>
	mov	FBA+2, r2
	beq	exit
	clr	ThisGr

410$:	clr	TrcLvl
	Trace	#2, r2, #0
	gos	Mark2,	<r2, #True>
	gos	T2Rec2,	<r2>
	bcs	exit
	tst	(r1)+
	beq	420$

	ErrTrc	#Err45

	br	exit

420$:	inc	NrFre2
	mov	(r1), r2
	bne	410$

EXIT:
	bit	#GrpCkP, WhtWrd
	bne	5$

	jmp	Result

5$:	call	pcr2lf
	Write	#Dub2T
	call	pcr2lf
	mov	#33., r5
	clr	r3

10$:	gos	Mark2,	<r5, #False>
	bcs	40$
	cmp	r3, #10
	beq	20$
	tst	r3
	beq	30$
	Write	#CSpT
	br	30$

20$:	clr	r3
	call	pcrlf

30$:	inc	r3
	mov	r5, r1
	clr	r0
	call	deco16
40$:	inc	r5
	cmp	MaxRec+2, r5
	bhis	10$

Result:	call	pcr2lf

	Write	#Chk3T
	call	CurDaT
	Write	#NrErrT
	mov	#NrAcc, r1
	clr	r0
	call	deco32
	Write	#DskAT
	call	pcr2lf
	Write	#NrErrT
	mov	Errors, r1
	clr	r0
	call	deco16
	Write	#FelT
	call	pcr2lf

	clr	r2
	mov	#1, r3
	mov	#3, r4

100$:	Write	#FlHdT
	mov	r3, r1
	clr	r0
	call	deco16
	Write	#TotT
	mov	r3, r1
	asl	r1
	mov	MaxRec-2(r1), r1
	clr	r0
	call	deco16
	Write	#RecsT

110$:	Write	#AntHdr
	Write	NRcHdr(r2), #-15
	mov	NodTbl(r2), r1
	mov	#-7, r0
	call	deco16
	call	pcrlf
	tst	(r2)+
	tst	NRcHdr(r2)
	bne	110$
	call	pcrlf
	asl	r3
	tst	(r2)+
	sob	r4, 100$

quit:	bic	#UtmOn, KSW
	call	UtmOff
	jmp	$Exit


proc	ChkGrZ,	<Obj, High, TypNod>

begin
	push	<r4, r3, r2>
	add	#2, TypNod(r5)
	cmp	#4, TypNod(r5)
	bhis	2$
	mov	#2, TypNod(r5)		; "N{tperson"
2$:	Trace	#1, Obj(r5), TypNod(r5)	; Error trace
	gos	TryRc1,	<Obj(r5), #FB2>
	bcs	5$			; bcc 999$
	gos	Mark1,	<Obj(r5), #True>
	mov	r1, r4
	cmp	TypNod(r5), (r4)	; Right nod-typ?
	beq	10$			; Yes!

	ErrTrc	#Err02
5$:	jmp	999$

10$:	cmp	6(r4), ThisGr
	beq	20$

	ErrTrc	#Err03

20$:	cmp	150(r4), High(r5)
	blos	30$

	ErrTrc	#Err04

30$:	tst	152(r4)
	beq	40$

	cmp	154(r4), 152(r4)
	blos	40$

	ErrTrc	#Err05

40$:	cmp	154(r4), High(r5)
	blos	50$

	ErrTrc	#Err06

50$:	cmp	156(r4), #30.
	blos	60$

	ErrTrc	#Err11
	br	100$

60$:	mov	r4, r1
	add	#20, r1

	gos	ChkTxt,	<#0>	; Check Presentation.

	gos	ChkMot,	<High(r5)>	; r4 must point rekord in FB2

100$:	cmp	#2, TypNod(r5)		; Netperson?
	beq	600$

	gos	ChkDsL,	<142(r4), 144(r4), 146(r4)>

	cmp	#4, TypNod(r5)		; Meeting?
	beq	400$			; Yes, branch to 400$

200$:	inc	NrPer			; One more PERSON!

	gos	ChkMES			; Ckeck all "MEDLEMSSKAP"

	bit	#1, 54(r4)
	bne	220$

	ErrTrc	#Err29

220$:	gos	ChkMrk			; Check all "MARKERADE"

	cmp	102(r4), High(r5)
	blos	240$

	ErrTrc	#Err30

240$:	mov	r4, r1
	add	#106, r1
	gos	ChkTxt,	<ThisGr>	; Check "Lapp p} d|rren"

	mov	114(r4), r0		; Check default tty.
	beq	280$
	cmp	#-1, r0			; (Ok{nd) sk{rm
	beq	280$
	gos	GetGrp,	<r0, #0>
	cmp	#4, (r1)
	beq	280$

	ErrTrc	#Err31

280$:	gos	ChkAli			; Check ALIAS.
	br	999$

400$:	inc	NrMee			; One more M\TE!

	gos	ChkMED
	br	999$

600$:	inc	NrNtP

	gos	ChkNDs			; Check N[TDISTRIBUTION

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

proc	ChkNDs				; Check all "N[TDISTRIBUTION"

Var	Nr,	word
Var	NxtR,	word
Var	PrvR,	word

begin
	push	TrcLvl
	mov	142(r4), Nr(r5)
	bne	40$

	tst	144(r4)
	bne	10$
	tst	146(r4)
	beq	999$

10$:	ErrTrc	#Err83

40$:	mov	144(r4), NxtR(r5)
	clr	PrvR(r5)

50$:	mov	NxtR(r5), r0
	bne	55$

	ErrTrc	#Err84
	br	999$

55$:	Trace	#1, r0, #12
	gos	Mark1,	<r0, #True>
	gos	TryRc1	<r0, #FB3>
	bcs	999$
	cmp	#12, (r1)
	beq	60$

	ErrTrc	#Err85
	br	999$

60$:	inc	NrNDs			; One more N[TDISTRIBUTION
	cmp	4(r1), PrvR(r5)
	beq	70$

	ErrTrc	#Err86

70$:	mov	NxtR(r5), PrvR(r5)
	mov	2(r1), NxtR(r5)

	movb	14(r1), r0
	bne	90$

80$:	ErrTrc	#Err88
	br	100$

90$:	cmp	#176-14-1, r0
	blo	80$

100$:	gos	ChkDsL,	<6(r1), 10(r1), 12(r1)>

	dec	Nr(r5)
	bne	50$
	tst	NxtR(r5)
	beq	110$

	ErrTrc	#Err83

110$:	cmp	PrvR(r5), 146(r4)
	beq	999$

	ErrTrc	#Err87

999$:	pop	TrcLvl
	ret

proc	ChkDsL,	<Nr, NxtR, LstR>

Var	PrvR,	word
Var	Lft,	word

begin
	push	<r2, r3, r4>

	push	TrcLvl
	clr	PrvR(r5)
	tst	Nr(r5)
	bne	20$

	tst	NxtR(r5)
	bne	10$
	tst	LstR(r5)
	beq	999$

10$:	ErrTrc	#Err72
	br	999$

20$:	mov	NxtR(r5), r0
	bne	40$

	ErrTrc	#Err73
	br	999$

40$:	mov	#20., Lft(r5)
	Trace	#1, r0, #10
	gos	Mark1,	<r0, #True>
	gos	TryRc1,	<r0, #FB3>
	cmp	#10, (r1)
	beq	60$

	ErrTrc	#Err74
	br	999$

60$:	inc	NrDST
	
	cmp	PrvR(r5), 4(r1)
	beq	80$

	ErrTrc	#Err75

80$:	mov	NxtR(r5), PrvR(r5)
	mov	2(r1), NxtR(r5)
	mov	r1, r2
	add	#10, r2

100$:	mov	(r2)+, r0

	gos	GetGrp, <r0,>
	bcs	999$

	cmp	#4, (r1)		; Terminal
	bne	120$

110$:	ErrTrc	#Err77
	br	999$

120$:	mov	(r2)+, r0
	beq	200$

	cmp	#10, (r1)
	bne	110$

	gos	ChkMtF,	<r0, (r2)>
	
200$:	tst	(r2)+
	dec	Nr(r5)
	beq	260$
	dec	Lft(r5)
	bne	100$
	br	20$

260$:	tst	NxtR(r5)
	bne	10$
	cmp	PrvR(r5), LstR(r5)
	beq	999$

	ErrTrc	#Err76

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

proc	ChkMtF,	<NxtR, LstR>		; Check all "MOTTAGETF[LT"

Var	PrvR,	word

begin
	push	TrcLvl

	tst	NxtR(r5)
	bne	40$
	tst	LstR(r5)
	beq	999$

10$:	ErrTrc	#Err78
	br	999$

40$:	clr	PrvR(r5)

50$:	mov	NxtR(r5), r0
	beq	200$
	Trace	#1, r0, #11
	gos	Mark1,	<r0, #True>
	gos	TryRc1	<r0, #FB3>
	bcs	999$
	cmp	#11, (r1)
	beq	60$

	ErrTrc	#Err80
	br	999$

60$:	inc	NrMtF			; One more "MOTAGETF[LT"
	cmp	4(r1), PrvR(r5)
	beq	70$

	ErrTrc	#Err81

70$:	mov	NxtR(r5), PrvR(r5)
	mov	2(r1), NxtR(r5)

100$:	movb	14(r1), r0
	bne	120$

110$:	ErrTrc	#Err82
	br	50$

120$:	cmp	#176-14-1, r0
	blo	110$
	br	50$

200$:	cmp	PrvR(r5), LstR(r5)
	beq	999$

	ErrTrc	#Err78

999$:	pop	TrcLvl
	ret

proc	ChkMrk				; Check all "MARKERADE"
Var	Nr,	word
Var	NxtR,	word
Var	PrvR,	word
Var	Lft,	word

begin
	push	TrcLvl
	mov	74(r4), Nr(r5)
	bne	40$

	tst	76(r4)
	bne	10$
	tst	100(r4)
	beq	999$

10$:	ErrTrc	#Err32

40$:	mov	76(r4), NxtR(r5)
	clr	PrvR(r5)

50$:	mov	NxtR(r5), r0
	bne	55$

	ErrTrc	#Err33
	br	999$

55$:	mov	#30., Lft(r5)
	Trace	#1, r0, #13
	gos	Mark1,	<r0, #True>
	gos	TryRc1	<r0, #FB3>
	bcs	999$
	cmp	#13, (r1)
	beq	60$

	ErrTrc	#Err34
	br	999$

60$:	inc	NrMrk			; One more MARKERAD.
	cmp	4(r1), PrvR(r5)
	beq	70$

	ErrTrc	#Err35

70$:	mov	NxtR(r5), PrvR(r5)
	mov	2(r1), NxtR(r5)
	add	#10, r1

80$:	gos	ChkTxt,	<#0>		; Don't care about receivers
	cmp	(r1)+, (r1)+
	dec	Nr(r5)
	beq	100$
	dec	Lft(r5)
	bne	80$
	br	50$

100$:	tst	NxtR(r5)
	beq	110$

	ErrTrc	#Err32

110$:	cmp	PrvR(r5), 100(r4)
	beq	999$

	ErrTrc	#Err36

999$:	pop	TrcLvl
	ret

proc	ChkAli				; Check all "ALIAS"

Var	Nr,	word
Var	NxtR,	word
Var	PrvR,	word

begin
	push	TrcLvl
	mov	116(r4), Nr(r5)
	bne	40$

	tst	120(r4)
	bne	10$
	tst	122(r4)
	beq	999$

10$:	ErrTrc	#Err67

40$:	mov	120(r4), NxtR(r5)
	clr	PrvR(r5)

50$:	mov	NxtR(r5), r0
	bne	55$

	ErrTrc	#Err68
	br	999$

55$:	Trace	#1, r0, #14
	gos	Mark1,	<r0, #True>
	gos	TryRc1	<r0, #FB3>
	bcs	999$
	cmp	#14, (r1)
	beq	60$

	ErrTrc	#Err69
	br	999$

60$:	inc	NrAli			; One more ALIAS
	cmp	4(r1), PrvR(r5)
	beq	70$

	ErrTrc	#Err70

70$:	mov	NxtR(r5), PrvR(r5)
	mov	2(r1), NxtR(r5)

100$:	dec	Nr(r5)
	bne	50$
	tst	NxtR(r5)
	beq	110$

	ErrTrc	#Err67

110$:	cmp	PrvR(r5), 122(r4)
	beq	999$

	ErrTrc	#Err71

999$:	pop	TrcLvl
	ret


proc	ChkMED				; Check "MEDLEMMAR"
Var	Nr,	word
Var	NxtR,	word
Var	PrvR,	word
Var	Lft,	word

begin
	push	TrcLvL

	mov	24(r4), Nr(r5)
	beq	999$

	mov	26(r4), NxtR(r5)
	clr	PrvR(r5)

10$:	mov	NxtR(r5), r0
	bne	20$

	ErrTrc	#Err25
	br	999$

20$:	mov	#61., Lft(r5)
	Trace	#1, r0, #5
	gos	Mark1,	<r0, #True>
	gos	TryRc1,	<r0, #FB3>
	bcs	999$
	cmp	#5, (r1)
	beq	30$

	ErrTrc	#Err26
	br	999$

30$:	inc	NrMED			; One more MEDLEMMAR.
	cmp	4(r1), PrvR(r5)
	beq	40$

	ErrTrc	#Err37

40$:	mov	NxtR(r5), PrvR(r5)
	mov	2(r1), NxtR(r5)
	add	#6, r1

50$:	gos	IsMesP,	<(r1)+>
	dec	Nr(r5)
	beq	70$
	dec	lft(r5)
	bne	50$
	br	10$

70$:	cmp	PrvR(r5), 30(r4)
	beq	80$

	ErrTrc	#Err38

80$:

999$:	pop	TrcLvl
	ret

proc	IsMesP,	<PerNr>
Var	Nr,	word
Var	Lft,	word

begin
	push	<r0, r1, r2, TrcLvl>
	mov	PerNr(r5), r0
	Trace	#4, r0, #1
	gos	GetGrp, <r0, #1>
	bcs	999$

10$:	mov	2(r1), r2

20$:	tst	r2
	bne	30$

	ErrTrc	#Err39
	br	999$

30$:	Trace	#1, r2, #3
	gos	TryRc1,	<r2, #FBB>
	bcs	999$
	cmp	#3, (r1)
	beq	40$

	ErrTrc	#Err40
	br	999$

40$:	cmp	6(r1), PerNr(r5)
	beq	50$

	ErrTrc	#Err03

50$:	mov	24(r1), Nr(r5)
	bne	70$

60$:	ErrTrc	#Err41
	br	999$

70$:	mov	26(r1), r2

100$:	tst	r2
	bne	110$

	ErrTrc	#Err20
	br	999$

110$:	mov	#20., Lft(r5)
	Trace	#1, r2, #6
	gos	TryRc1,	<r2, #FBB>
	bcs	999$
	cmp	#6, (r1)+
	beq	115$

	ErrTrc	#Err17
	br	999$

115$:	mov	(r1)+, r2
	cmp	(r1)+, (r1)+

120$:	cmp	(r1)+, ThisGr
	beq	140$
	cmp	(r1)+, (r1)+
	dec	Nr(r5)
	beq	60$
	dec	Lft(r5)
	bne	120$
	br	100$

140$:	

999$:	pop	<TrcLvl, r2, r1, r0>
	ret

proc	ChkMES				; Check "MEDLEMSSKAP"
Var	Nr,	word
Var	NxtR,	word
Var	PrvR,	word
Var	Lft,	word

begin
	push	TrcLvL
	mov	24(r4), Nr(r5)
	beq	999$

	mov	26(r4), NxtR(r5)
	clr	PrvR(r5)

10$:	mov	NxtR(r5), r0
	bne	20$

	ErrTrc	#Err20
	br	999$

20$:	mov	#20., Lft(r5)
	gos	Mark1,	<r0, #True>
	Trace	#1, r0, #6
	gos	TryRc1,	<r0, #FB3>
	bcs	999$
	cmp	#6, (r1)
	beq	30$

	ErrTrc	#Err17
	br	999$

30$:	inc	NrMES			; One more MEDLEMSSKAP.
	cmp	4(r1), PrvR(r5)
	beq	40$

	ErrTrc	#Err18

40$:	mov	NxtR(r5), PrvR(r5)
	mov	2(r1), NxtR(r5)
	add	#10, r1

50$:	gos	IsMemP,	<(r1)+, (r1)+, (r1)+>
	dec	Nr(r5)
	beq	70$
	dec	lft(r5)
	bne	50$
	br	10$

70$:	cmp	PrvR(r5), 30(r4)
	beq	80$

	ErrTrc	#Err19

80$:

999$:	pop	TrcLvl
	ret

proc	IsMemP,	<MetNr, ReadNr, StaRec>
Var	Nr,	word
Var	Lft,	word

begin
	push	<r0, r1, r2, TrcLvl>
	mov	MetNr(r5), r0
	Trace	#4, r0, #2
	gos	GetGrp,	<r0, #2>
	bcc	10$
	jmp	999$

10$:	mov	2(r1), r2
	cmp	4(r1), ReadNr(r5)
	bhis	20$

	ErrTrc	#Err24

20$:	tst	r2
	bne	30$

	ErrTrc	#Err22
	br	999$

30$:	Trace	#1, r2, #4
	gos	TryRc1,	<r2, #FBB>
	bcs	999$
	cmp	#4, (r1)
	beq	40$

	ErrTrc	#Err23
	br	999$

40$:	cmp	6(r1), MetNr(r5)
	beq	50$

	ErrTrc	#Err03

50$:	mov	24(r1), Nr(r5)
	bne	70$

60$:	ErrTrc	#Err27
	br	999$

70$:	mov	26(r1), r2

100$:	tst	r2
	bne	110$

	ErrTrc	#Err25
	br	999$

110$:	mov	#61., Lft(r5)
	Trace	#1, r2, #5
	gos	TryRc1,	<r2, #FBB>
	bcs	999$
	cmp	#5, (r1)+
	beq	115$

	ErrTrc	#Err26
	br	999$

115$:	mov	(r1)+, r2
	tst	(r1)+

120$:	cmp	(r1)+, ThisGr
	beq	140$
	dec	Nr(r5)
	beq	60$
	dec	Lft(r5)
	bne	120$
	br	100$

140$:	
	mov	StaRec(r5), r2
	beq	200$
	Trace	#2, r2, #4
	gos	Mark2,	<r2, #True>
	gos	TryRc2,	<r2, #FB4>
	bcs	200$
	cmp	#4, (r1)
	beq	150$

	ErrTrc	#Err28
	br	999$


150$:	inc	NrSta

	; **** Testa fler referenser ****

200$:	

999$:	pop	<TrcLvl, r2, r1, r0>
	ret

proc	ChkMot,	<High>
Var	NxtR,	word
Var	PrvR,	word
Var	Lft,	word
Var	TLvl,	word

begin
	push	<r2, r3, r4, TrcLvl>
	mov	TrcLvl, TLvl(r5)
	tst	High(r5)
	beq	999$
	sub	150(r4), High(r5)
	mov	32(r4), NxtR(r5)
	clr	PrvR(r5)
	mov	156(r4), r2
	mov	#30., Lft(r5)
	sub	r2, Lft(r5)
	asl	r2
	asl	r2
	add	#10, r2
	
10$:	tst	NxtR(r5)
	bne	15$
	
	ErrTrc	#Err10
	br	999$

15$:	mov	TLvl(r5), TrcLvl
	Trace	#1, NxtR(r5), #7
	gos	Mark1,	<NxtR(r5), #True>
	gos	TryRc1,	<NxtR(r5), #FB3>
	bcs	999$
	cmp	#7, (r1)
	beq	20$

	ErrTrc	#Err07
	br	999$

20$:	inc	NrMOT			; One more MOTTAGIT.
	cmp	4(r1), PrvR(r5)
	beq	30$

	ErrTrc	#Err08

30$:	mov	NxtR(r5), PrvR(r5)
	mov	2(r1), NxtR(r5)
	add	r2, r1
	
40$:	gos	Chktxt,	<ThisGr>	; r1 points to longword
	cmp	(r1)+, (r1)+
	dec	High(r5)
	beq	70$
	dec	lft(r5)
	bne	40$

	mov	#30., Lft(r5)
	mov	#10, r2
	br	10$	

70$:	tst	NxtR(r5)
	beq	80$

	ErrTrc	#Err09

80$:	cmp	PrvR(r5), 34(r4)
	beq	999$

	ErrTrc	#Err12

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

proc	VerTxt,	<Obj>			; Verify Text-rekord

begin
	push	<r0, r1, r3>
	mov	r1, r3
	cmp	#1, (r3)
	beq	50$

	ErrTrc	#Err14
	br	999$

50$:	gos	T2Rec5,	<2(r3), 4(r3)>
	bcs	999$
	cmp	(r1), Obj(r5)
	beq	100$

	ErrTrc	#Err49
	br	999$

100$:	tst	(pc)+
999$:	sec
	pop	<r3, r1, r0>
	ret

proc	ChkMuR

Var	NxtR,	word
Var	PrvR,	word
Var	MaxMuR,	word

begin
	push	<r0, r1, TrcLvl>
	bit	#xMulR, 14(r2)
	bne	40$
	tst	34(r2)
	bne	10$
	tst	36(r2)
	beq	999$

10$:	ErrTrc	#Err56
	br	999$

40$:	mov	34(r2), NxtR(r5)
	mov	ThisTx, PrvR(r5)
	mov	#1000., MaxMuR(r5)

50$:	cmp	NxtR(r5), ThisTx
	beq	100$			; One complete turn!
	trace	#2, NxtR(r5), #1
	gos	T2Rec2,	<NxtR(r5)>
	bcs	999$
	gos	VerTxt,	<NxtR(r5)>
	bcs	999$
	cmp	20(r2), 20(r1)
	bne	60$
	cmp	22(r2), 22(r1)
	beq	70$

60$:	ErrTrc	#Err57

70$:	cmp	36(r1), PrvR(r5)
	beq	80$

	ErrTrc	#Err58

80$:	mov	NxtR(r5), PrvR(r5)
	mov	34(r1), NxtR(r5)
	dec	MaxMuR(r5)
	bne	50$

	ErrTrc	#Err59
	br	999$

100$:	cmp	36(r2), PrvR(r5)
	beq	999$

	ErrTrc	#Err58

999$:	pop	<TrcLvl, r1, r0>
	ret

proc	ChkCTT

begin
	push	<r0, r1, r3, TrcLvl>
	mov	32(r2), r3
	beq	999$
	Trace	#2, r3, #1
	gos	T2Rec2,	<r3>
	bcs	999$
	gos	VerTxt,	<r3>
	bcs	999$
	cmp	ThisTx, 24(r1)
	beq	40$

	ErrTrc	#Err60
	br	999$

40$:

999$:	pop	<TrcLvl, r3, r1, r0>
	ret	


proc	ChkCTL

begin
	push	<TrcLvl, r0, r1, r4>
	bit	#xKom, 14(r2)
	bne	20$
	tst	26(r2)
	bne	10$
	tst	30(r2)
	beq	999$

10$:	ErrTrc	#Err65
	br	999$

20$:	mov	26(r2), r4
	beq	200$
	Trace	#2, r4, #1
	gos	T2Rec2, <r4>
	bcs	200$
	gos	VerTxt,	<r4>
	bcs	200$
	cmp	24(r2), 24(r1)
	beq	200$

	ErrTrc	#Err66

200$:	mov	30(r2), r4
	beq	400$
	Trace	#2, r4, #1
	gos	T2Rec2, <r4>
	bcs	400$
	gos	VerTxt,	<r4>
	bcs	400$
	cmp	24(r2), 24(r1)
	beq	400$

	ErrTrc	#Err66

400$:	
999$:	pop	<r4, r1, r0, TrcLvl>
	ret

proc	ChkTCT

begin
	push	<TrcLvl, r0, r1, r2, r3, r4>
	bit	#xKom, 14(r2)
	bne	40$
	tst	24(r2)
	beq	999$

	ErrTrc	#Err48
	br	999$

40$:	mov	24(r2), r4
	bne	45$

	ErrTrc	#Err53
	br	999$

45$:	Trace	#2, r4, #1
	gos	T2Rec2,	<r4>
	bcs	999$
	gos	VerTxt,	<r4>
	bcs	999$

60$:	cmp	4(r1), 4(r2)
	blo	80$
	bhi	70$
	cmp	2(r1), 2(r2)
	blo	80$

70$:	ErrTrc	#Err50

80$:
999$:	pop	<r4, r3, r2, r1, r0, TrcLvL>
	ret

proc	ChkTxt,	<receiv>

begin
	push	<r0, r1, r2, r3, r4, TrcLvl>
	mov	r1, r4
	Trace	#5, (r1), 2(r1)
	tst	(r1)
	bne	5$
	tst	2(r1)
	beq	999$

5$:	cmp	2(r1), TxtHig+2
	blo	20$
	bhi	10$
	cmp	(r1), TxtHig
	blos	20$

10$:	ErrTrc	#Err13
	br	999$

20$:	mov	#FBA, r0
	call	FysTst

	tst	r0
	beq	999$
	
	Trace	#2, r0, #1
	gos	TryRc2,	<r0, #FB4>
	bcs	999$
	cmp	#1, (r1)
	beq	40$

	ErrTrc	#Err14
	br	999$

40$:	cmp	2(r1), (r4)+
	bne	50$
	cmp	4(r1), (r4)
	beq	60$

50$:	ErrTrc	#Err15

60$:	mov	Receiv(r5), r0
	beq	70$			; Don't check receiver
	cmp	16(r1), r0
	beq	70$

	ErrTrc	#Err16

70$:

999$:	pop	<TrcLvl, r4, r3, r2, r1, r0>
	ret

proc	PutTrc,	<File, Rec, Typ>

begin
	push	r1
	mov	#TrcLst, r1
	add	TrcLvl, r1
	cmp	#TrcLst+2000, r1
	bhi	10$
	ErrTrc	#LstFul
	clr	TrcLvl
	mov	#TrcLst, r1

10$:	mov	File(r5), (r1)+
	mov	Rec(r5), (r1)+
	mov	Typ(r5), (r1)+
	add	#6, TrcLvl
	pop	r1
	ret

proc	TrcErr	<ErrMsg>

Var	LstFil,	word
Var	LstTyp,	word
Var	Nr,	word

begin
	push	<r2, r1, r0>
	inc	Errors
	clr	LstFil(r5)
	clr	LstTyp(r5)
	clr	Nr(r5)

	mov	ThisGr, r0
	beq	5$
	cmp	r0, LsErGr
	beq	5$

	mov	r0, LsErGr
	call	pcrlf
	Write	#GrpT
	mov	#-10, r0
	mov	ThisGr, r1
	call	deco16
	Write	ThisNa
	call	pcrlf
5$:	clr	r2

10$:	cmp	TrcLvl, r2
	beq	50$
	cmp	TrcLst(r2), LstFil(r5)
	bne	12$

	cmp	LstFil(r5), #5
	beq	1010$
	cmp	TrcLst+4(r2), LstTyp(r5)
	beq	1000$

	call	pcrlf
	mov	#11, r0
	call	ttyout			; Print a tab.
	mov	LstFil(r5), r1
	br	14$
	
1000$:	Write	#CSpT
	inc	Nr(r5)
	cmp	Nr(r5), #7
	blo	25$
	clr	Nr(r5)
	clr	LstTyp(r5)
	br	25$
	
1010$:	Write	#CSpT
	inc	Nr(r5)
	cmp	Nr(r5), #6
	blo	16$
	clr	Nr(r5)
	clr	LstFil(r5)
	br	16$

12$:	call	pcrlf
	Write	#FilT
	mov	TrcLst(r2), r1
	mov	r1, LstFil(r5)
	mov	#2,r0
	call	deco16
14$:	mov	#11, r0
	call	TtyOut
	cmp	#5, r1
	bne	20$


	Write	#TxtNod, #-16
16$:	mov	r2, r1
	add	#TrcLst+2, r1
	clr	r0
	call	deco32
	br	30$

20$:	asl	r1
	mov	RecTyp(r1), r1	
	mov	TrcLst+4(r2), r0
	mov	r0, LstTyp(r5)
	asl	r0
	add	r0, r1
	Write	(r1), #-16
25$:	clr	r0
	mov	TrcLst+2(r2), r1
	call	deco16

30$:	add	#6, r2
	br	10$

50$:	call	pcrlf
	Write	#IndT
	Write	ErrMsg(r5)
	call	pcrlf
	pop	<r0, r1, r2>
	ret
		

CurDaT:	.date
	mov	#ThsDat+2, r1
	mov	xrb+2, (r1)
	mov	xrb, -(r1)
	call	PrtDat
	call	pcr2lf
	rts	pc

proc	TryRc1,	<rec, buf>

begin
	cmp	MaxRec, rec(r5)
	bhis	10$

	ErrTrc	#Err42
	sec
	br	999$

10$:	add	#1, NrAcc
	adc	NrAcc+2
	gos	TryRec,	<#1, rec(r5), buf(r5),>
99$:	clc
999$:	ret

proc	TryRc2,	<rec, buf>

begin
	cmp	MaxRec+2, rec(r5)
	bhis	10$

	ErrTrc	#Err43
	sec
	br	999$

10$:	add	#1, NrAcc
	adc	NrAcc+2
	gos	TryRec,	<#2, rec(r5), buf(r5),>
99$:	clc
999$:	ret

proc	Mark2,	<obj, errlog>

begin
	push	<r0, r1, r2, r3, r4>
	mov	obj(r5), r3
	dec	r3
	clr	r2
	clr	r4
	div	#20, r2
	asl	r2
	cmp	#20000, r2
	bhis	5$
	mov	obj(r5), r0
	bpt
	jmp	quit

5$:	mov	#1, r1
	ash	r3, r1
	bit	r1, BitMp2(r2)
	beq	10$
	dec	r4			; Doubel allocation.
10$:	bis	r1, BitMp2(r2)
	tst	r4
	beq	99$
	tst	errlog(r5)
	beq	20$
	ErrTrc	#Err61
20$:	sec
99$:	pop	<r4, r3, r2, r1, r0>
	ret

proc	Mark1,	<obj, errlog>

begin
	push	<r0, r1, r2, r3, r4>
	mov	obj(r5), r3
	dec	r3
	clr	r2
	clr	r4
	div	#20, r2
	asl	r2
	cmp	#4000, r2
	bhis	5$
	mov	obj(r5), r0
	bpt
	jmp	quit

5$:	mov	#1, r1
	ash	r3, r1
	bit	r1, BitMp1(r2)
	beq	10$
	dec	r4			; Doubel allocation.
10$:	bis	r1, BitMp1(r2)
	tst	r4
	beq	99$
	tst	errlog(r5)
	beq	20$
	ErrTrc	#Err61
20$:	sec
99$:	pop	<r4, r3, r2, r1, r0>
	ret

proc	T2Rec5,	<low, high>

begin
	push	<r3, r4>
	mov	high(r5), r0
	mov	low(r5), r1
	cmp	r0, TxtHig+2
	bhi	10$
	blo	20$
	cmp	r1, TxtHig
	blos	20$

10$:	ErrTrc	#Err13
	br	200$

20$:	tst	r0
	bne	30$
	tst	r1
	bne	30$

	ErrTrc	#Err44
	br	200$

30$:	add	#1, NrAcc
	adc	NrAcc+2
	call	rtob5
	mov	#Bufs1, r3

40$:	mov	(r3)+, r4
	beq	50$

	cmp	-2(r4), r0
	bne	40$

	add	r4, r1
	br	100$

50$:	mov	CurBu1, r3
	gos	Get,	<#5, r0, Bufs1(r3), #1,>
	add	Bufs1(r3), r1
	add	#2, CurBu1
	bic	#10, CurBu1		; Make it circular!
	
100$:	tst	(pc)+
200$:	sec
	pop	<r4, r3>
	ret

proc	T2Rec2,	<rec>

begin
	push	<r3, r4>
	tst	rec(r5)
	beq	10$
	cmp	rec(r5), MaxRec+2
	blos	20$

10$:	ErrTrc	#Err43
	br	200$

20$:	add	#1, NrAcc
	adc	NrAcc+2
	mov	#BufsA, r3

40$:	mov	(r3)+, r4
	beq	50$

	gos	TstRec,	<#2, rec(r5), r4>
	bcc	100$
	br	40$

50$:	mov	CurBuA, r3
	gos	GetRec,	<#2, rec(r5), BufsA(r3),>
	add	#2, CurBuA
	bic	#10, CurBuA		; Make it circular!
	
100$:	tst	(pc)+
200$:	sec
	pop	<r4, r3>
	ret


proc	GetGrp,	<Nr, NodTyp>

begin
	cmp	Nr(r5), MaxRec+6
	blos	10$

	ErrTrc	#Err62
	br	200$

10$:	tst	Nr(r5)
	bne	20$


	ErrTrc	#Err63
	br	200$

20$:	gos	TryRec,	<#4, Nr(r5), #FBD, >
	add	#1, NrAcc
	adc	NrAcc+2
	tst	NodTyp(r5)
	beq	100$
	tst	(r1)
	bne	30$

	ErrTrc	#Err21
	br	200$

30$:	cmp	NodTyp(r5), (r1)
	beq	100$

	ErrTrc	#Err64
	br	200$

100$:	tst	(pc)+
200$:	sec
	ret

	sect	var
	
	.word	0
FBA::	.blkb	1000
	.word	0
FBB::	.blkb	1000
	.word	0
FBC::	.blkb	1000
	.word	0
FBD::	.blkb	1000

CurBu1:	.word	0

Bufs1:	.word	FB1
	.word	FB2
	.word	FB3
	.word	FB4
	.word	0

CurBuA:	.word	0

BufsA:	.word	FBA
	.word	FBB
	.word	FBC
	.word	FBD
	.word	0

FilSiz:	.blkw	6

MaxRec:	.blkw	6

NrAcc:	.blkw0	2

Errors:	.word	0

TxtHig:	.word	0, 0
NrGrp:	.word	0

WhtWrd:	.word	-1

NodTbl:
NrFre1:	.word	0
NrNtP:	.word	0
NrPer:	.word	0			; This words must be in this order.
NrMee:	.word	0
NrMed:	.word	0
NrMes:	.word	0
NrMot:	.word	0
NrDst:	.word	0
NrMtF:	.word	0
NrNds:	.word	0
NrMrk:	.word	0
NrAli:	.word	0
	.word	0
NrFre2:	.word	0
NrTxt:	.word	0
	.word	0
NrSta:	.word	0
	.word	0
NrPNa:	.word	0
NrMNa:	.word	0
NrTty:	.word	0
NrNPN:	.word	0
	.word	0

NRcHdr:	.word	FreNod
	.word	NtPNod
	.word	PrsNod
	.word	MetNod
	.word	MEDNod
	.word	MESNod
	.word	MOTNod
	.word	DstNod
	.word	MtFNod
	.word	NDsNod
	.word	MrkNod
	.word	AliNod
	.word	0
	.word	FreNod
	.word	TXTNod
	.word	MrkNod
	.word	StaNod
	.word	0
	.word	PNaNod
	.word	MNaNod
	.word	TTyNod
	.word	0


RecTyp:	.word	0
	.word	Rc1Typ
	.word	Rc2Typ
	.word	0
	.word	Rc4Typ

Rc1Typ:	.word	FreNod
	.word	InfNod
	.word	NtPNod
	.word	PrsNod
	.word	MetNod
	.word	MedNod
	.word	MesNod
	.word	MotNod
	.word	DstNod
	.word	MtFNod
	.word	NDsNod
	.word	MrkNod
	.word	AliNod

Rc2typ:	.word	FreNod
	.word	TxtNod
	.word	MrkNod
	.word	StaNod

Rc4Typ:	.word	OpeNod
	.word	PNaNod
	.word	MNaNod
	.word	NoNod
	.word	TTYNOD

ThisGr:	.word	0
ThisNa:	.word	0
ThisTx:	.word	0

LsErGr:	.word	0

TxtCop:	.blkw	20

TrcLvl:	.word	0
TrcLst:	.blkw	1000

ThsDat:	.blkw0	2

	.word
BitMp1::.blkw0	2000
	.word
BitMp2::.blkw0	10000
	.word			; Safty catch...
EoBmp::

Text	DBSTXT,	<"DBSCHK Ver 1.01 ">

Text	Chk1T,	<"***  Check 1. (Grupper)  - ">
Text	Chk2T,	<"***  Check 2. (Texter)   - ">
Text	Chk3T,	<"***  Sammanfattning - ">

Text	DubT,	<"Fria records i fil 1:">
Text	Dub2T,	<"Fria records i fil 2:">
Text	NrErrT,	<"Totalt ">
Text	DskAT,	<" diskaccesser.">
Text	FelT,	<" funna fel."<Cr><Lf>>
Text	AntHdr,	<"Antal ">

Text	NoNod,	<"Felnod">
Text	FreNod,	<"Oanv{nd">
Text	InfNod,	<"INFO">
Text	NtPNod,	<"N[TPERSON">
Text	PrsNod,	<"PERSON">
Text	MetNod,	<"M\TE">
Text	MedNod, <"MEDLEMMAR">
Text	MesNod, <"MEDLEMSSKAP">
Text	MotNod,	<"MOTTAGET">
Text	DstNod,	<"DISTRUBUTION">
Text	MtFNod,	<"MOTTAGARF[LT">
Text	NDsNod,	<"N[TDIST">

Text	AliNod,	<"ALIAS">
Text	TxtNod,	<"TEXT">
Text	MrkNod,	<"MARKERADE">
Text	StaNod,	<"START">
Text	OpeNod,	<"OPERSON">
Text	PNaNod,	<"P-namn">
Text	MNaNod,	<"M-namn">
Text	TTYNod,	<"TERMINAL">

Text	qmprm,	<"? ">
Text	CSpT,	<", ">
Text	WhtTxt,	<"Vad ska kontrolleras <Allt>">
Text	LogFT,	<"Logfil               <_KB:>">
Text	GrpT,	<"GRUPP ">
Text	FilT,	<"	Fil ">
Text	RecT,	<" Record ">
Text	IndT,	<"	?">
Text	FlHdT,	<"Fil ">
Text	TotT,	<" totalt ">
Text	RecsT,	<" records."<Cr><Lf><Cr><Lf>>
Text	LstFul,	<"Sp}rlistan {r full">


Text	Err01,	<"Felaktig nod typ.">
Text	Err02,	<"Nodtyperna i fil 4 och 1 olika.">
Text	Err03,	<"Felaktigt gruppnummer.">
Text	Err04,	<"Fler borttagna texter {n skapade.">
Text	Err05,	<"F|rm}nga aktiva texter">
Text	Err06,	<"Fler aktiva {n skapade texter.">
Text	Err07,	<"Felaktit MOTTAGET-record - avbryter text kontroll.">
Text	Err08,	<"Felaktig bak}treferens till MOTTAGET.">
Text	Err09,	<"Referens till |verfl|digt MOTTAGET record.">
Text	Err10,	<"Noll referens till MOTTAGET.">
Text	Err11,	<"Position (Ord 156) utanf|r MOTTAGET-noden.">
Text	Err12,	<"Felaktig referens till sista MOTTAGET-noden .">
Text	Err13,	<"F|rstort textnummer.">
Text	Err14,	<"Felaktigt textrecord.">
Text	Err15,	<"Felaktigt logisktnummer i TEXT-noden">
Text	Err16,	<"Felaktig mottagare till texten.">
Text	Err17,	<"Felaktit MEDLEMSSPAPs-record - avbryter kontroll.">
Text	Err18,	<"Felaktig bak}treferens till MEDLEMSSKAP.">
Text	Err19,	<"Felaktig referens till sista MEDLEMSSKAPs-noden .">
Text	Err20,	<"Noll referens till MEDLEMSSKAP.">
Text	Err21,	<"Gruppen finns inte.">
Text	Err22,	<"Noll referens till M\TE.">
Text	Err23,	<"Felaktig M\TEs-record.">
Text	Err24,	<"Fler l{sta inl{gg {n vad som finns i m|tet.">
Text	Err25,	<"Noll referens till MEDLEMMAR.">
Text	Err26,	<"Felaktig MEDLEMMAR-record.">
Text	Err27	<"Personen {r ej med i m|tet.">
Text	Err28,	<"Felaktigt start-record.">
Text	Err29,	<"L|senordet ej konverterat fr}n Ver 3.2.">
Text	Err30,	<"Fler l{sta brev {n vad som mottagits.">
Text	Err31,	<"Felaktig referens till favorit TERMINAL-typ.">
Text	Err32,	<"Referens till on|digt MARKERADE-record.">
Text	Err33,	<"Noll referens till MARKERADE.">
Text	Err34,	<"Felaktig MARKERADE-record.">
Text	Err35,	<"Felaktig bak}treferens till MARKERADE.">
Text	Err36,	<"Felaktig referens till sista MARKERADE-noden .">
Text	Err37,	<"Felaktig bak}treferens till MEDLEMMAR.">
Text	Err38,	<"Felaktig referens till sista MEDLEMMAR.">
Text	Err39,	<"Noll referens till PERSON.">
Text	Err40,	<"Felaktig PERSON-nod.">
Text	Err41,	<"M|tet ing}r ej i PERSONens MEDLEMSSKAPs-lista.">
Text	Err42,	<"Recordnummer utanf|r fil 1.">
Text	Err43,	<"Recordnummer utanf|r fil 2.">
Text	Err44,	<"Referens till TEXT 0.">
Text	Err45,	<"Felaktigt OANV[ND-nod.">
Text	Err46,	<"Text referens utanf|r fil 3.">
Text	Err47,	<"Extern-text referens utanf|r fil 3.">
Text	Err48,	<"F|reg}ende kommentar referens till icke kommentar.">
Text	Err49,	<"Fel textreferens. Kommentaren {r troligtvis utpl}nad.">
Text	Err50,	<"Den kommenterade texten har ej l{gre textnummer.">
Text	Err51,	<"Den kommenterade texten har inte texten som kommentar.">
Text	Err52,	<"Cirkul{r kommentark{dja.">
Text	Err53,	<"Kommentar bit satt, men ingen TEXT-referens.">
Text	Err54,	<"Troligtvis cirkul{r kommentar k{dja - avbryter.">
Text	Err55,	<"Felaktig referens till f|reg}ende kommentar  (ord 26).">
Text	Err56,	<"Texten har flera mottagare-l{nkar men inte bit satt.">
Text	Err57,	<"Olika textreferenser (fil 3) vid flera mottagare.">
Text	Err58,	<"Felaktig bak}t referens till flera mottagre.">
Text	Err59,	<"Felaktig fleramottagre lista (mer {n tusen mottagre).">
Text	Err60,	<"Kommenterande text har ingen referens tillbaka.">
Text	Err61,	<"Dubbel allocerat record.">
Text	Err62,	<"F|rstort gruppnummer">
Text	Err63,	<"Referens till grupp nummer noll.">
Text	Err64,	<"Referens till fel typ av grupp.">
Text	Err65,	<"N{sta/f|reg}ende referens fr}n icke kommentar.">
Text	Err66,	</Olika "det kommenterade" till texter p} smma niv}./>
Text	Err67,	<"Referens till on|digt ALIAS-record.">
Text	Err68,	<"Noll referens till ALIAS.">
Text	Err69,	<"Felaktigt ALIAS-record.">
Text	Err70,	<"Felaktig bak}treferens till ALIAS.">
Text	Err71,	<"Felaktig referens till sista ALIAS-noden .">
Text	Err72,	<"Referens till on|digt DISTRIBUTIONS-record">
Text	Err73,	<"Nollreferens till DISTRIBUTION.">
Text	Err74,	<"Felaktigt DISTRIBUTION-record.">
Text	Err75,	<"Felaktig bak}treferens till DISTRIBUTION.">
Text	Err76,	<"Felaktig referens till sista DISTRIBUTION-noden .">
Text	Err77,	<"Felaktig typ av grupp i DISTRIBUTIONS-listan.">
Text	Err78,	<"Felaktig referens till sista MOTTAGETF[LTet.">
Text	Err80,	<"Felaktigt MOTTAGARF[LT">
Text	Err81,	<"Felaktig bak}treferens till MOTTAGETF[LT.">
Text	Err82,	<"Otill}ten l{ngd p} MOTTAGETF[LTet">
Text	Err83,	<"Referens till on|digt N[TDISTRIBUTION-record.">
Text	Err84,	<"Noll referens till N[TDISTRIBUTION.">
Text	Err85,	<"Felaktigt N[TDISTRIBUTION-record.">
Text	Err86,	<"Felaktig bak}treferens till N[TDISTRIBUTION.">
Text	Err87,	<"Felaktig referens till sista N[TDISTRIBUTION-noden .">
Text	Err88,	<"Otill}ten l{ngd p} N[TDISTRIBUTIONen">

	.even

Makc	LogLst,1,<"(Filnamn)">,Nil,xStr,Nil,1,0
Makc	WhtLst,GrpCkP,<"Gruppcheck">,C1,xList+xAnd,C1,1,1
Makc	C1,TxtCkP,<"Textcheck">,Nil,xList+xAnd,WhtLst,2,2

	.even

KOMDEV:	.word	"DR
KOMDVN:	.byte	1
	.byte	377
KOMPPN:	.byte	3.
	.byte	10.	

Files:	.RAD50	"DAT""1  "		; Extension & 2'nd word
	.RAD50	"DAT""2  "		;  in file name
	.RAD50	"DAT""3  "
	.RAD50	"DAT""4  "
	.RAD50	"DAT""5  "
EOFS:

EOF::	.END	INIT