.title	aux

	.includ	"b:global.mac"
	
	sect	code

;+
; Mutex_Begin
;-

MtxBgn:	push	<r0, r1>
	push	CurSek
	mov	#Mutex, r1
	call	GetAdr
	cmp	Job, 2(r1)		; Am I the owner already?
	beq	99$
	mov	#400., r0

10$:	inc	(r1)+			; Try to get it!
	beq	20$			; Yes, we got it!

	dec	-(r1)			; No, we don't...
	mov	#1., xrb		; Sleep time (1 sek)
	.sleep
	sob	r0, 10$

	Write	#ErrMsg
	jmp	MainLp

20$:	mov	Job, (r1)		; We are in control now!
	
99$:	pop	r1
	call	PopSek
	pop	<r1, r0>
	rts	pc

;+
; Mutex_End
;-

MtxEnd:	push	<r0, r1>
	push	CurSek
	mov	#Mutex, r1
	call	GetAdr
	cmp	Job, 2(r1)
	bne	99$
	
	clr	2(r1)
	dec	(r1)

99$:	pop	r1
	call	PopSek
	pop	<r1, r0>
	rts	pc


;+
; S{tt
;-

$SET:	REPARS	#2, #VVDS
	bcs	99$
	mov	Found(r0), r1
	call	GetAdr
	jmp	@(r1)

99$:	rts	pc

;+
; FindAd letar efter internet addresen.
; Anrop:	r1, Pekar p} Str{ngen att leta efter.
;		r0, Kommando lista |ver grupper.
; Return:	r0, Pekar p} funnet kommando.
;		carryn satt om ingen grupp hittad.
;-

FindAd:	push	<r3, r2, r1>
	mov	r0, r1
	clr	FB3-2
5$:	call	GetAdr
	mov	r1, r3
	cmp	rPri1(r1), #1
	beq	10$
	cmp	rPri1(r1), #2
	bne	30$
10$:	gos	TryRec,	<#1, rArg(r1), #FB3, #UnLock>
	add	#160, r1
	mov	@sp, r0
	call	EqualP
	bcc	50$			; Found!
30$:	mov	rNxt(r3), r1
	bne	5$
	sec				; Not Found....
50$:	mov	r3, r0
	pop	<r1, r2, r3>
	rts	pc

;+
; MOVTTD "Move Terminal Def." 
; Anrop:	r1, Pekare till kommando listan i minnet.
; F|rst|r FB3.
;-


MOVTTD:	push	<r0,r1,r2,r3>
	mov	(r1), pterm
	mov	#TTFlag, r2
	mov	(r1), r1
	beq	50$
	cmp	#-1, r1
	beq	50$
	gos	GetRec, <#4, r1, #FB3, #Unlock>
	mov	4(r1), (r2)+
	add	#26, r1
	clr	MaxLin
	bisb	(r1)+, MaxLin		; # lines
	clr	Width			; Width
	bisb	(r1)+, Width
	mov	(r1)+, r3		; Antal definitions rader.
	beq	60$
10$:	clr	r0
	bisb	(r1)+, r0
	movb	r0, (r2)+
	bic	#200,r0
	beq	30$
20$:	movb	(r1)+, (r2)+
	sob	r0, 20$
30$:	sob	r3, 10$
	br	99$

50$:	clr	(r2)+			; Flag word
	mov	#24., MaxLin		; # lines
	mov	#80., Width		; TTY Width
60$:	clr	(r2)+			; Erol
	clr	(r2)+			; Erase rest of screen.
	clr	(r2)+			; Safety....

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

SetWai:	bis	#WaitEn, KSW
	rts	pc

upper:	push	<r0, r1, r2>
	movb	tmpstr, r0
	beq	30$
	mov	#tmpstr+1, r1
10$:	movb	(r1), r2
	cmp	r2, #'a
	blo	20$
	cmp	r2, #'}
	bhi	20$
	bicb	#40, r2
	movb	r2, (r1)

20$:	inc	r1
	sob	r0, 10$
30$:	pop	<r2, r1, r0>
	rts	pc

;+
; MAKLST skapar en ny GROUP-lista och l{nkarin denna i GRPLST.
; Anrop:	r0 	=> Pekare p} fil-buffurten.
;		r1	=> Logiskt grupp-nummer.
;		NxtAdr	=> "First Free byte in LIB"
;		LstAdr	=> "Previous Linked Group"
;		LibSiz	=> Lib:ets storlek
;-

Maklst:	push	<r3,r0,r2,r1>
	mov	(r0)+, r2		 ; Spara grupp typ
	mov	#xList!xGroup!xNoarg, r3 ; Kommandotyp.

	mov	LstAdr,r1
	beq	10$
	call	GetAdr
	mov	NxtAdr, rNxt(r1)	; L{nkar in det nya objektet.
	cmp	#10, r2
	bne	10$
	add	#4, rNxt(r1)		; Skapa plats f|r en l{nk

10$:	mov	NxtAdr, r1
	mov	r1, LstAdr
	call	GetAdr
	cmp	#10, r2			; N{tPerson?
	bne	12$

	mov	#177757, (r1)+		; Link prioritet
	mov	#NAdLst, (r1)+		; Link pekare.
	bis	#xLink!xAND, r3
	add	#4, LstAdr

12$:	mov	(sp), (r1)+		; Grupp Nr (rNum)
	clr	(r1)+			; N{sta grupp. (rNxt)
	mov	(r0)+, (r1)+		; Fysiskt grupp-nummer. (rArg)
	mov	r2, (r1)+		; Typ av grupp (rPri1)
	mov	(r0)+, (r1)+		; HIGH (rHigh = rPri2)
	movb	r3, (r1)+		; Typ av kommando
14$:	clr	r2
	bisb	(r0)+,r2
	movb	r2,(r1)+
20$:	movb	(r0)+,(r1)+
	sob	r2,20$
	inc	r1
	bic	#1,r1			; .Even (!)
	sub	#BasAdr, r1
	mov	r1, r2
	add	#70., r2
	bit	#160000, r2
	bne	30$
	bic	#17776, NxtAdr
	bis	r1 , NxtAdr
	br	40$

30$:	mov	NxtAdr, r1
	bic	#17776, r1
	swab	r1
	add	#40, r1
	mov	r1, r0
	sub	ResLim, r0
	cmp	LibSiz, r0
	bhi	35$
	mov	#-1, NxtAdr
	br	40$

35$:	swab	r1
	mov	r1, NxtAdr

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

; +
; MakAli l{gger upp an Alias i minnet.
; Anrop:	r0, Record nummer till ALIAS objektet.
;		r1, Pekare till ALIAS noden i minnet.
;-

MakAli:	push	<r4, r3, r2, r1, r0>

	mov	NxtMem, r4
	mov	LstMem, r3

	cmp	#-1, r4
	beq	99$

	mov	r1, r2
	mov	r4, 2(r3)		; rNxt for previous command
	mov	r4, LstMem
	mov	10(r2), (r4)+
	mov	#GRPLST, (r4)+		; rNxt
	mov	r0, (r4)+		; rArg
	mov	6(r2), (r4)		; rPri1
	bis	#200, (r4)+
	clr	(r4)+			; rPri2 = rHigh
	movb	#xGroup!xNoArg, (r4)+
	add	#20, r1
	clr	r0
	bisb	(r1)+, r0
	movb	r0, (r4)+
20$:	movb	(r1)+, (r4)+		; Move alias-name
	sob	r0, 20$
	cmp	#20, 6(r2)		; Internet-address?
	bne	50$			; No => br 50$

	add	#110, r2
	clr	r0
	bisb	(r2)+, r0
	movb	r0, (r4)+
	beq	50$
30$:	movb	(r2)+, (r4)+		; Move internet-address.
	sob	r0, 30$

50$:	inc	r4
	bic	#1, r4			; ".even"
 
	mov	r4, NxtMem

	add	#2*55.+6., r4
	mov	r4, r0
	bic	#17776, r4
	swab	r4
	sub	ResLim, r4		; Are we in memory or in reslib?
	bmi	80$

	mov	#-1, NxtMem
	br	99$

80$:	call	SetCor

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

;+
; LNKGRP l{nkar in en grupp i grupp listan
; Anrop:	Nr,	Gruppens logiska nummer.
; 		Adr,	Pekare till fil 4 buffer.
;		buf,	Filbuffert som f|rst|rs
;
; F|rst|r LstAdr och NxtAdr
;+

Proc	LnkGrp	<Nr, Adr, Buf>

Begin
	push	<r0,r1>	
	mov	#LSTGRP, r1
	call	GetAdr
	mov	(r1)+, LstAdr
	mov	(r1)+, NxtAdr
	mov	(r1)+, LibSiz
	mov	Nr(r5), r1
	mov	Adr(r5), r0
	call	MakLst
	mov	#LSTGRP, r1
	call	GetAdr
	mov	LstAdr, (r1)+
	mov	NxtAdr, (r1)
	pop	<r1,r0>
	Ret

;+
; SETCOR utf|r ett ".core"
; H|gsta adressen ska ligga i r0
;-

SETCOR:	push	r0
	ash	#-13,r0
	inc	r0
	cmp	r0, MemLim
	beq	10$
	mov	r0, MemLim
	movb	r0,@#xrb
	.core
	call	error
10$:	pop	r0
	rts	pc

;+
; PopSek mappar tillbaka reslib:et.
; Anrop:	 r1,	Ska inneh}lla orginal CurSek
;-

PopSek:	cmp	r1, CurSek
	beq	rt$

	clr	-(sp)
	jmp	DoMap

;+
; GETADR konverterar s.k. cmd-pekare  i r1 till
; addresser samt (om n|dv{ndigt) mapp:ar in r{tt 
; sektion.  (Returnerar addressen  i r1)
;-

GETADR:	bit	#UseRes, KSW		; Do we have a reslib?
	beq	rt$			; No, return r1 as it is...
	push	r1
	bic	#17776, r1
	swab	r1
	sub	ResLim, r1		; Are we in memory or in reslib?
	bge	10$

	pop	r1			; Memory!
	br	rt$

10$:	cmp	CurSek, r1		; Right section?
	beq	cnt$

DoMap:	mov	r1, CurSek		; No, Get it!
	asl	r1
	asl	r1
	push	r1
	call	clrfqb
	movb	#MAPFQ, Firqb+Fqfil
	movb	WinIde, Firqb+fqppn
	mov	#Firqb+Fqext,r1
	mov	LibIde, (r1)+
	mov	(sp)+, (r1)+
	mov	#128., (r1)+
	mov	#2, (r1)
	.plas
	call	Error

Cnt$:	pop	r1
	bic	#160001, r1
	add	#BasAdr, r1
rt$:	clc
	rts	pc
	
;+
; FixGrp gets group number and net-name.
; Call		r0 => Index to found.
; Return	r0 => Index to next command.
; 		r1 => Pointer to NetName string or zero
;		r2 => Groupnumber.
; Return carry set if no good group was found.
;-

FixGrp:	push	r3
	mov	Found(r0), r1
	cmp	#NetLst, r1
	beq	50$
	tst	(r0)+
	call	GetAdr
	bitb	#xGroup, rTyp(r1)
	beq	4711$
	mov	(r1), r2
	beq	4711$
	bit	#200, rPri1(r1)
	beq	10$
	bit	#20, rPri1(r1)
	beq	4711$
	add	#rStr, r1
	push	r0
	movb	(r1)+, r0
	add	r0, r1
	pop	r0
	br	1000$

10$:	bit	#10, rPri1(r1)
	beq	999$

	mov	r0, r1
	asr	r1
	cmp	Level, r1
	blos	999$

	mov	Found(r0), r1
	cmp	#NAdLst, r1
	bne	999$
	br	70$

50$:	mov	#LibInf, r1
	call	GetAdr
	mov	16(r1), r2

70$:	mov	Strs(r0), r1
	tst	(r0)+
	mov	Strs(r0), r3
	sub	r1, r3
	dec	r3
	beq	999$
	movb	r3, -(r1)
	br	1000$

999$:	clr	r1
1000$:	tst	(pc)+
4711$:	sec
	pop	r3
	rts	pc

;++
; FIXLST testar om grupp-namnet var givet som person: x
; [r s} fallet s{tts Found(r0) att peka p} n{sta byte i found och
; dess ineh}ll byts ut mot en pekare till r{tt GROUP-lista.
; Om gruppen ej existerar s{tts carryn.
; Anrop:	r0 => (Niv}-1)*2.  (Index till found)
; Return:	r0 =>  -"-	   (Eventuelt en niv} h|gre)
;--

FIXLST:	push	<r1, r2>
	mov	Found(r0), r1
	call	GetAdr

	bit	#xGroup, rTyp(r1)
	beq	80$
	bit	#200, rPri1(r1)		; Alias?
	beq	80$

	bit	#20, rPri1(r1)
	bne	100$

60$:	push	r0
	mov	(r1), r0
	mov	#GRPLST, r1
	call	FindCm
	tst	r0
	bne	65$
	sec
65$:	pop	r0
	bcs	200$
	mov	FinPtr, Found(r0)
	br	100$

80$:	tst	(r1)
	bne	100$
	bit	#20, rPri1(r1)		; Internet-address
	bne	100$

	tst	(r0)+
	mov	r0,r2
	tst	(r0)+
	asr	r0
	cmp	r0,@#Level
	bhi	200$
	asl	r0	
	mov	Strs(r0),r0
	mov	Strs(r2),r1
	sub	r1,r0
	call	val16
	mov	#GRPLST,r1
	gos	findcm
	tst	r0
	beq	200$
	mov	rPri1-rStr(r0), r0
	mov	Found-2(r2),r1
	call	GetAdr
	bit	r0, rPri1(r1)
	beq	200$
	mov	FinPtr,Found(r2)
	mov	r2,r0
100$:	clc
	br	255$

200$:	Write	#PEJ
	sec
255$:	pop	<r2,r1>
377$:	rts	pc

.rem &

;+
; NetAli moves the internetaddress into users command-line (PStr1).
; Call:		r0, index to found.
;		r1, pointer to alias command in memory.
;-

NetAli:	push	<r0, r1, r2, r3, r4, r5>
	mov	#NetLst, Found(r0)
	mov	r0, r5
	add	#rStr, r1
	clr	r2
	bisb	(r1)+, r2
	add	r2, r1
	clr	r2
	bisb	(r1)+, r2

	push	<r2, r1>		; Len, Pos

	add	#Strs, r0
	mov	(r0)+, r3
	mov	(r0), r4
	sub	r3, r4
	dec	r4
	sub	r4, r2

	asr	r5
	sub	Level, r5
	neg	r5
10$:	add	r2, (r0)+		; Alter index in Strs
	sob	r5, 10$
	bisb	PStr1, r5
	add	r2, r5
	movb	r5, PStr1		; Alter total length.

	tst	r2			; Is the new string longer?
	beq	70$			; No, equaly long.
	bmi	50$			; No, shorter.

	clrb	(r3)			; End flag
	mov	-(r0), r0
	mov	r0, r1
	sub	r2, r0
40$:	movb	-(r0), -(r1)		; Need more space!
	bne	40$
	br	70$

50$:	mov	-(r0), r0
	clrb	(r0)
	mov	r3, r0
	mov	r3, r1
	sub	r2, r1
60$:	movb	(r1)+, (r0)+		; Don't need so much space!
	bne	60$	

70$:	pop	<r1, r0>		; Pos, Len

80$:	movb	(r1)+, (r3)+
	sob	r0, 80$

	pop	<r5, r4, r3, r2, r1, r0>
	rts	pc

; &	


;+ Data passed: R1, The address of a 2-word block containing date in RSTS/E
;		    internal format.
;-
PrtDat:	push	<r0, r1>
	mov	(r1)+, firqb+4
	beq	40$
	mov	(r1), firqb+22
	mov	#-1, r1
	bit	#xISO, @#MyFlag
	beq	10$

	neg	r1

10$:	movb	#uu.cnv, firqb+fqfun
	mov	r1, firqb+6
	mov	#1, firqb+24		; 24-hour time
	.uuo	
	mov	#firqb+10, r1
	mov	#firqb+21, r0
20$:	cmpb	-(r0), #40
	beq	20$			; Discard trailing spaces
	sub	r1, r0
	inc	r0
	Call	Print			; Write date
	write	#ComSpc			; Comma and space!
	
	mov	#firqb+26, r1
	mov	#5, r0
	Call	Print
	bit	#xISO, @#MyFlag
	beq	30$
	mov	#40, r0
	call	TtyOut
30$:	pop	<r1, r0>
	rts	pc

40$:	write	#Never
	br	30$


;++
; PRTNAM skriver ut namnet p} person vars nummer ligger i r0
; Om gruppen {r en operson skrivs "operson: namn" ut.
;--

Prtnam:	push	<r1,r0>
	push	CurSek			; Store sektion.
	mov	#GRPLST,r1
	gos	findcm
	mov	r0,r1
	beq	30$
	call	strout
10$:	pop	r1
	call	PopSek			; Restore users maped sektion
	pop	<r0,r1>
	rts	pc

30$:	Write	#Opers
	mov	2(sp), r0
	sub	#1000, sp
	mov	sp, r1
	gos	getrec, <#4, r0, r1, #Unlock>
	add	#6, r1
	call	strout
	add	#1000, sp
	br	10$

;+
; Data passed:
;	R0 = (level-1)*2 (index into Strs and Found)
; Data returned:
;	R1/R0 = Long unsigned integer.
; 	Carry set if "text (nummer)"  but no number was given.
;-

FixTxt:	push	r2
	mov	Found(r0), r1
	call	GetAdr
	tst	(r1)
	bge	100$

	tst	(r0)+
	mov	r0,r2
	tst	(r0)+
	asr	r0
	cmp	r0, Level
	blos	20$
	sec
	br	999$
20$:	mov	r2, r0
100$:	call	GetNum
999$:	pop	r2
	rts	pc

;+
; Data passed:
;	R0 = (level-1)*2 (index into Strs and Found)
; Data returned:
;	R1/R0 = Long unsigned integer.
;-

GetNum:	
	mov	Found(r0), r1
	call	GetAdr
	bit	#xNet, rTyp(r1)
	bne	10$

	; Normal number.

	mov	Strs(r0), r1
	mov	Strs+2(r0), r0
	sub	r1, r0
	dec	r0
	call	Val32
	br	99$

	; message-id

10$:	mov	Strs(r0), r1
	mov	Strs+2(r0), r0
	sub	r1, r0
	dec	r0
	call	GetHsh
	bcc	99$
	mov	#-1, r0
	mov	r0, r1
99$:	rts	pc

Gval:	push	r1
	mov	Strs(r0), r1
	mov	Strs+2(r0), r0
	sub	r1, r0
	call	Val16
	pop	r1
	rts	pc

RELINK:	mov	#Mutex, r1		; In case we forgotten to 
	call	GetAdr			;  releas our semaphore
	cmp	2(r1), Job
	bne	2$
	dec	(r1)+
	clr	(r1)

2$:	mov	#LibInf, r1
	call	GetAdr
	mov	r1, r5
	bit	#1, 12(r5)
	beq	5$
	mov	#FB3, r3
	gos	Get,	<#1, #2, r3, #1, #Unlock>
	cmp	PPN,6(r3)
	beq	5$
	mov	#KHJSA,r1
	call	Messut
	jmp	sluta

5$:	cmp	#xLibRd, (r5)
	beq	10$
	iot

10$:	mov	6(r5), r5
	cmp	r5, EditNr
	beq	377$
	
	mov	r5, EditNr
	mov	Me, r0
	mov	#GRPLST,r1
	gos	findcm
	tst	r0
	bne	20$
	mov	#DHBU,r1
	call	Messut
	clr	Me
	jmp	Sluta

20$:	mov	Thsgr, r0
	beq	377$
	call	Findcm
	tst	r0
	bne	377$
	mov	#HBU, r1
	call	Messut
	clr	r1
	call	GoToIt

377$:	rts	pc

Messut:	clrb	xrb+xrci
	.postn
	tstb	xrb+xrbc
	beq	10$
	call	pcrlf
	call	pcrlf
10$:	call	strout
	rts	pc

;++
; AMBTST testar om en str{ng {r unik som grupp-namn
; Anrop:	r0 => L{ngden av str{ngen.
;		r1 => Pekare till str{ngen.
; Returnerar carry:n satt om namnet ej var unikt samtidigt
; som r0 inneh}ller nummret till den listan som var flertydig.
;--

AMBTST:	push	<r5, r4, r3, r2, r1, r0>
	push	CurSek
	mov	#-1, r4			; Flag
	tst	r0
	beq	377$
	cmp	#StrMax, r0
	blo	377$
	mov	#Pstr2, r2
	gos	cvt$$, <r1, r2, r0, #7>
	mov	r2, r5
	clr	r0
	bisb	(r2)+, r0
	beq	377$
	cmpb	#'_, (r2)
	beq	377$
5$:	cmpb	#'@, (r2)+
	beq	377$
	sob	r0, 5$
	mov	#Meet1, r1

10$:	call	GetAdr
	mov	r1, r4
	tst	rPri1(r4)
	beq	200$
	add	#rStr, r1
	clr	r3
	bisb	(r1)+, r3
	mov	#PStr3, r0
	gos	cvt$$, <r1, r0, r3, #7>
	mov	r5, r1
	call	equalp
	bcc	350$
200$:	mov	rNxt(r4), r1
	bne	10$
	clr	r4
	br	377$

350$:	mov	(r4), r4

377$:	pop	r1
	call	PopSek			; Restore maped section.
	pop	r0
	tst	r4
	beq	999$
	mov	r4, r0
	sec
999$:	pop	<r1, r2, r3, r4, r5>
	rts	pc	

; Who are present (Vilka {r n{rvarande)
Vilka:	
	bis	#UtmOn, KSW
	mov	#PRELST, r1
	call	GetAdr
	mov	r1, r2
	mov	#64., r3
	clr	r4			; Init flag!

10$:	mov	(r2)+, r5
	bne	20$
	tst	(r2)+
	cmp	(r2)+, (r2)+
	br	30$
20$:	tst	r4
	bne	25$
	write	#header
25$:	call	70$
	mov	#PreLst, r1
	call	GetAdr			; Get first sektion again!
30$:	sob	r3, 10$

	tst	r4
	beq	60$
	call	PCRLF
	bic	#UtmOn, KSW
60$:	rts	pc

70$:	inc	r4			; Set flag
	mov	r2, r1
	sub	#BasAdr+PreLst, r1
	bic	#160001, r1
	asr	r1			; r0 will contain a job number.
	asr	r1
	asr	r1
	mov	#40, r0
	cmp	r1, Job
	bne	75$
	mov	#'*, r0
75$:	call	ttyout
	mov	#2, r0
	call	Deco16
	mov	#40, r0
	call	ttyout

	mov	r2, r1
	mov	#2, r0
	add	r0, r1
	call	printn

	mov	#40, r0
	call	ttyout
	mov	r5, r0
	mov	(r2)+, r5		; Get meeting before it's to late.
	cmp	(r2)+, (r2)+
	mov	#GrpLst, r1
	call	FindCm
	gos	shortn <r0, #FB3, #28.>
	mov	r0, tmp
	mov	#FB3, tmp+2
	clr	tmp+4
	mov	r1, tmp+6
	mov	r5, r0
	beq	80$
	
	mov	#GrpLst, r1
	call	FindCm
	gos	shortn <r0, tmp+6, #40.>
	mov	r0, tmp+4

80$:	mov	#-30., r0
	tst	tmp			; No line?
	bne	85$
	neg	r0
	call	SpcOut
	br	90$
85$:	mov	tmp+2, r1
	call	100$			; Type and update pointer.
	mov	r1, tmp+2
	dec	tmp
90$:	mov	#-41., r0
	tst	tmp+4
	beq	95$		
	mov	tmp+6, r1
	call	100$
	mov	r1, tmp+6
	dec	tmp+4
95$:	call	PCRLF
	tst	tmp
	bne	97$
	cmp	tmp, tmp+4
	beq	99$
97$:	mov	#7, r0
	call	SpcOut
	br	80$
99$:	rts	pc

100$:	call	Strouf
	clr	r0
	bisb	(r1)+, r0
	add	r0, r1
	rts	pc

;+
; MovPro moves a string to PrsPro (max 79. bytes)
; Data passed:	r0, Address of string
; Data returned	r0, Address of PrsPro
;-

MovPro:	push	r1
	mov	#PrsPro, r1
	cmpb	#79., (r0)
	bhis	10$
	movb	#79., (r0)
10$:	call	MovStr
	mov	r1, r0
	pop	r1
	rts	pc

;+ MOVSTR moves a STRING.
; Data passed:	r0, Address of source string.
;		r1, Address of destination area.
;
; No data is returned.
;-
MOVSTR:	push	<r0, r1, r2>
	clr	r2
	bisb	(r0), r2
	inc	r2
10$:	movb	(r0)+, (r1)+
	sob	r2, 10$
	pop	<r2, r1, r0>
	rts	pc

CTRLO:
	push	<r1, r0>
1$:	clr	firqb+fqfil
	movb	#UU.FCB, firqb+fqfun
	.uuo
	tst	firqb+4			; ^O i effect?
	bmi	15$			; Yes, bit 15 set.
	mov	#firqb+14, r0
	tst	(r0)+			; ^S (output stoped)?
	bmi	10$			; Yes, sleep a second.
	cmp	(r0)+, (r0)+		; Is output-buffer empty?
	beq	20$			; Yes, exit to where we came from.
	cmp	(r0), #6		; System constant.
					; Word 8 of DDB when idle - 3.
	bhis	1$

10$:	mov	#1, xrb
	.sleep
	br	1$

15$:	.ttrst
	write	#CTOO
	pop	<r0, r1>
	sec
	rts	pc

20$:	.ttrst
25$:	pop	<r0, r1>
	clc
	rts	pc


setn:					; Set .NAME
					; Last 2 bytes in r0
	push	<r3, r2, r1, r0>
	mov	#firqb+fqnam1, r2
	call	clrfqb
	mov	#^rKOM, (r2)+
	mov	#^r.  , (r2)
	tst	r0	
	bne	100$
	mov	#"  , (sp)	; Two space
	mov	#^r .., r0
	br	110$

100$:	call	500$
	mov	r0, (sp)
	mov	r3, r0

110$:	add	r0, (r2)
	.name

	mov	#PRELST, r1
	call	GetAdr
	mov	job, r0
	asl	r0
	asl	r0
	asl	r0
	add	r0, r1
	cmp	(r1)+, (r1)+
	mov	(sp), (r1)
	pop	<r0, r1, r2, r3>
	rts	pc

500$:	push	<r2, r4>
	mov	r0, -(sp)
	mov	sp, r2
	movb	(r2), r3
	call	600$
	movb	r3, (r2)
	movb	1(r2), r3
	call	600$
	movb	r3, 1(r2)

	clr	r3
	bisb	(r2), r3
	sub	#'@, r3
	mul	#50, r3
	mov	r3, r4
	clr	r3
	bisb	1(r2), r3
	sub	#'@, r3
	add	r4, r3
	mov	(sp)+, r0
	pop	<r4, r2>
	rts	pc

600$:	bic	#^c177, r3
	cmpb	r3, #'Z
	blos	610$
	sub	#'a-'A, r3
610$:	cmp	r3, #'A
	bhis	630$
	movb	#'A, r3
630$:	rts	pc



; Strings

Text	CTOO,	<"^O"<cr><lf><lf>>
Text	Never,	<"Aldrig          ">
Text	ComSpc,	<", ">
Text	Opers,	<"Operson ">
;Text	o1,	<"Me: ">
;Text	o2,	<<15><12>"MyFlag: ">
;Text	o3,	<<15><12>"MyPriv: ">
;Text	o4,	<"BLK: ">
Text	PEJ,	<"Gruppen/terminalen existerar ej"<15><12><12>>
Text	DHIR,	<"Du har inte r{tt att utf|ra detta kommando"<15><12><12>>
Text	header,	<"Job    Namn			     M|te"<CR><LF>>
Text	DHBU,	<"Otur! Du har just blivit utpl}nad."<CR><LF><LF>>
Text	HBU,	<"Detta m|te har just blivit utp}nat. (Du tvingas d{rf|r uttr{da)"<CR><LF><LF>>
Text	KHJSA,	<"KOM har just st{ngts av. "<cr><lf><lf>>
Text	BadTxt, <"Texten existerar inte"<cr><lf>>
Text	VVDS,	<"Vad vill du s{tta">
Text	ErrMsg,	<"Lyckas ej f} skrivacces - Bryter."<Cr><Lf><Lf>>

	.even

	.end