code: 9ferno

ref: 9661fb64092acfcf370688c5e56934e400965822
dir: /appl/wm/samstub.b/

implement Samstub;

include "sys.m";
sys: Sys;
fprint, FD, fildes: import sys;

stderr: ref FD;

include "draw.m";
draw: Draw;

include "samterm.m";
samterm: Samterm;
Text, Menu, Context, Flayer, Section: import samterm;

include "samtk.m";
samtk: Samtk;
panic, whichtext, whichmenu: import samtk;

include "samstub.m";

sendsam:	chan of ref Sammsg;
recvsam:	chan of ref Sammsg;

snarflen:	int;

ctxt: ref Context;

requested: list of (int, int);

tname := array [] of {
	"Tversion",
	"Tstartcmdfile",
	"Tcheck",
	"Trequest",
	"Torigin",
	"Tstartfile",
	"Tworkfile",
	"Ttype",
	"Tcut",
	"Tpaste",
	"Tsnarf",
	"Tstartnewfile",
	"Twrite",
	"Tclose",
	"Tlook",
	"Tsearch",
	"Tsend",
	"Tdclick",
	"Tstartsnarf",
	"Tsetsnarf",
	"Tack",
	"Texit",
};

hname := array [] of {
	"Hversion",
	"Hbindname",
	"Hcurrent",
	"Hnewname",
	"Hmovname",
	"Hgrow",
	"Hcheck0",
	"Hcheck",
	"Hunlock",
	"Hdata",
	"Horigin",
	"Hunlockfile",
	"Hsetdot",
	"Hgrowdata",
	"Hmoveto",
	"Hclean",
	"Hdirty",
	"Hcut",
	"Hsetpat",
	"Hdelname",
	"Hclose",
	"Hsetsnarf",
	"Hsnarflen",
	"Hack",
	"Hexit",
};

init(c: ref Context)
{
	ctxt = c;
	sys = load Sys Sys->PATH;
	draw = load Draw Draw->PATH;

	stderr = fildes(2);

	samterm = load Samterm Samterm->PATH;

	samtk = load Samtk Samtk->PATH;
	samtk->init(ctxt);

	requested = nil;
}

start(): (ref Samio, chan of ref Sammsg)
{
	sys = load Sys Sys->PATH;

	sys->bind("#C", "/", sys->MAFTER);

	# Allocate a cmd device
	ctl := sys->open("/cmd/clone", sys->ORDWR);
	if(ctl == nil) {
		fprint(stderr, "can't open /cmd/clone\n");
		return (nil, nil);
	}

	# Find out which one
	buf := array[32] of byte;
	n := sys->read(ctl, buf, len buf);
	if(n <= 0) {
		fprint(stderr, "can't read cmd device\n");
		return (nil, nil);
	}

	dir := "/cmd/"+string buf[0:n];

	# Start the Command
	n = sys->fprint(ctl, "exec "+ SAM);
	if(n <= 0) {
		fprint(stderr, "can't exec %s\n", SAM);
		return (nil, nil);
	}

	data := sys->open(dir+"/data", sys->ORDWR);
	if(data == nil) {
		fprint(stderr, "can't open cmd data file\n");
		return (nil, nil);
	}

	sendsam = chan of ref Sammsg;
	recvsam = chan of ref Sammsg;

	samio := ref Samio(ctl, data, array[1] of byte, 0, 0);

	spawn sender(samio, sendsam);
	spawn receiver(samio, recvsam);

	return (samio, recvsam);
}

sender(samio: ref Samio, c: chan of ref Sammsg)
{
	fprint(ctxt.logfd, "sender started\n");
	for (;;) {
		h := <- c;
		if (h == nil) return;
		buf := array[3 + len h.mdata] of byte;
		buf[0] = byte h.mtype;
		buf[1] = byte h.mcount;
		buf[2] = byte (h.mcount >> 8);
		buf[3:] = h.mdata;
		sys->write(samio.data, buf, len buf);
	}
}

receiver(samio: ref Samio, msgchan: chan of ref Sammsg)
{
	c: int;

	fprint(ctxt.logfd, "receiver started\n");

	state := 0;
	i := 0;
	errs := 0;

	h: ref Sammsg;

	for (;;) {
		if (samio.count == 0) {
			n := sys->read(samio.data, samio.buffer, len samio.buffer);
			#sys->fprint(stderr, "fd = %d ­ len = %d\n", samio.data.fd, len samio.buffer);
			if (n <= 0) {
				fprint(stderr, "Read error on sam's pipe ⇒ %r\n");
				return;
			}
			samio.index = 0;
			samio.count = n;
		}
		samio.count--;

		c = int samio.buffer[samio.index++];

		case state {
		0 =>
			h = ref Sammsg(c, 0, nil);
			state++;
			continue;
		1 =>
			h.mcount = c;
			state++;
			continue;
		2 =>
			h.mcount = h.mcount|(c<<8);
			if (h.mcount > DATASIZE || h.mcount < 0)
				panic("receiver: count>DATASIZE");
			if(h.mcount != 0) {
				h.mdata = array[h.mcount] of byte;
				i = 0;
				state++;
				continue;
			}
		3 =>
			h.mdata[i++] = byte c;
			if(i < h.mcount){
				continue;
			}
		}
		msgchan <- = h;
		h = nil;
		state = 0;
	}
}

inmesg(h: ref Sammsg): int
{

	case h.mtype {

	Hversion =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hversion: %d\n", m);

	Hbindname =>
		m := h.inshort(0);
		vl := h.invlong(2);
		fprint(ctxt.logfd, "Hbindname: %ux, %bux\n", m, vl);
		bindname(m, int vl);

	Hcurrent =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hcurrent: %d\n", m);
		hcurrent(m);

	Hmovname =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hmovname: %d, %s\n", m, string h.mdata[2:]);
		movename(m, string h.mdata[2:]);

	Hgrow =>
		m := h.inshort(0);
		l1 := h.inlong(2);
		l2 := h.inlong(6);
		fprint(ctxt.logfd, "Hgrow: %d, %d, %d\n", m, l1, l2);
		hgrow(m, l1, l2);

	Hnewname =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hnewname: %d\n", m);
		newname(m);

	Hcheck0 =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hcheck0: %d\n", m);
		i := whichmenu(m);
		if (i >= 0) {
			t := ctxt.menus[i].text;
			if (t != nil)
				t.lock++;
			outTs(Tcheck, m);
		}

	Hcheck =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hcheck: %d\n", m);
		i := whichmenu(m);
		if (i >= 0) {
			t := ctxt.menus[i].text;
			if (t != nil && t.lock)
				t.lock--;
			hcheck(t);
		}

	Hunlock =>
		fprint(ctxt.logfd, "Hunlock\n");
		clrlock();

	Hdata =>
		m := h.inshort(0);
		l := h.inlong(2);
		fprint(ctxt.logfd, "Hdata: %d, %d, %s\n",
			m, l, contract(string h.mdata[6:]));
		hdata(m, l, string h.mdata[6:]);

	Horigin =>
		m := h.inshort(0);
		l := h.inlong(2);
		fprint(ctxt.logfd, "Horigin: %d, %d\n", m, l);
		horigin(m, l);

	Hunlockfile =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hunlockfile: %d\n", m);
		clrlock();

	Hsetdot =>
		m := h.inshort(0);
		l1 := h.inlong(2);
		l2 := h.inlong(6);
		fprint(ctxt.logfd, "Hsetdot: %d, %d, %d\n", m, l1, l2);
		hsetdot(m, l1, l2);

	Hgrowdata =>
		m := h.inshort(0);
		l1 := h.inlong(2);
		l2 := h.inlong(6);
		fprint(ctxt.logfd, "Hgrowdata: %d, %d, %d, %s\n",
			m, l1, l2, contract(string h.mdata[10:]));
		hgrowdata(m, l1, l2, string h.mdata[10:]);

	Hmoveto =>
		m := h.inshort(0);
		l := h.inlong(2);
		fprint(ctxt.logfd, "Hmoveto: %d, %d\n", m, l);
		hmoveto(m, l);

	Hclean =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hclean: %d\n", m);
		hclean(m);

	Hdirty =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hdirty: %d\n", m);
		hdirty(m);

	Hdelname =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hdelname: %d\n", m);
		hdelname(m);

	Hcut =>
		m := h.inshort(0);
		l1 := h.inlong(2);
		l2 := h.inlong(6);
		fprint(ctxt.logfd, "Hcut: %d, %d, %d\n",
			m, l1, l2);
		hcut(m, l1, l2);

	Hclose =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hclose: %d\n", m);
		hclose(m);

	Hsetpat =>
		fprint(ctxt.logfd, "Hsetpat: %s\n", string h.mdata);
		samtk->hsetpat(string h.mdata);

	Hsetsnarf =>
		m := h.inshort(0);
		fprint(ctxt.logfd, "Hsetsnarf: %d\n", m);

	Hsnarflen =>
		snarflen = h.inlong(0);
		fprint(ctxt.logfd, "Hsnarflen: %d\n", snarflen);

	Hack =>
		fprint(ctxt.logfd, "Hack\n");
		outT0(Tack);

	Hexit =>
		fprint(ctxt.logfd, "Hexit\n");
		return 1;

	-1 =>
		panic("rcv error");

	* =>
		fprint(ctxt.logfd, "type %d\n", h.mtype);
		panic("rcv unknown");
	}
	return 0;
}

Sammsg.inshort(h: self ref Sammsg, n: int): int
{
	return	((int h.mdata[n+1])<<8) |
		((int h.mdata[n]));
}

Sammsg.inlong(h: self ref Sammsg, n: int): int
{
	return	((int h.mdata[n+3])<<24) |
		((int h.mdata[n+2])<<16) |
		((int h.mdata[n+1])<< 8) |
		((int h.mdata[n]));
}

Sammsg.invlong(h: self ref Sammsg, n: int): big
{
	return	((big h.mdata[n+7])<<56) |
		((big h.mdata[n+6])<<48) |
		((big h.mdata[n+5])<<40) |
		((big h.mdata[n+4])<<32) |
		((big h.mdata[n+3])<<24) |
		((big h.mdata[n+2])<<16) |
		((big h.mdata[n+1])<< 8) |
		((big h.mdata[n]));
}

Sammsg.outcopy(h: self ref Sammsg, pos: int, data: array of byte)
{
	h.mdata[pos:] = data;
}

Sammsg.outshort(h: self ref Sammsg, pos: int, s: int)
{
	h.mdata[pos++]	= byte s;
	h.mdata[pos]	= byte (s >> 8);
}

Sammsg.outlong(h: self ref Sammsg, pos: int, s: int)
{
	h.mdata[pos++]	= byte s;
	h.mdata[pos++]	= byte (s >> 8);
	h.mdata[pos++]	= byte (s >> 16);
	h.mdata[pos]	= byte (s >> 24);
}

Sammsg.outvlong(h: self ref Sammsg, pos: int, s: big)
{
	h.mdata[pos++]	= byte s;
	h.mdata[pos++]	= byte (s >> 8);
	h.mdata[pos++]	= byte (s >> 16);
	h.mdata[pos++]	= byte (s >> 24);
	h.mdata[pos++]	= byte (s >> 32);
	h.mdata[pos++]	= byte (s >> 40);
	h.mdata[pos++]	= byte (s >> 48);
	h.mdata[pos]	= byte (s >> 56);
}

outT0(t: int)
{
	fprint(ctxt.logfd, "\t\t\t\t\t%s\n", tname[t]);
	h := ref Sammsg(t, 0, nil);
	sendsam <- = h;
}

outTs(t, s: int)
{
	fprint(ctxt.logfd, "\t\t\t\t\t%s %ux\n", tname[t], s);
	a := array[2] of byte;
	h := ref Sammsg(t, 2, a);
	h.outshort(0, s);
	sendsam <- = h;
}
	
outTv(t: int, i: big)
{
	fprint(ctxt.logfd, "\t\t\t\t\t%s %bux\n", tname[t], i);
	a := array[8] of byte;
	h := ref Sammsg(t, 8, a);
	h.outvlong(0, i);
	sendsam <- = h;
}

outTsll(t, m, l1, l2: int)
{	fprint(ctxt.logfd, "\t\t\t\t\t%s %d %d %d\n", tname[t], m, l1, l2);
	a := array[10] of byte;
	h := ref Sammsg(t, 10, a);
	h.outshort(0, m);
	h.outlong(2, l1);
	h.outlong(6, l2);
	sendsam <- = h;
}

outTsl(t, m, l: int)
{	fprint(ctxt.logfd, "\t\t\t\t\t%s %d %d\n", tname[t], m, l);
	a := array[6] of byte;
	h := ref Sammsg(t, 6, a);
	h.outshort(0, m);
	h.outlong(2, l);
	sendsam <- = h;
}

outTsls(t, m, l1, l2: int)
{	fprint(ctxt.logfd, "\t\t\t\t\t%s %d %d %d\n", tname[t], m, l1, l2);
	a := array[8] of byte;
	h := ref Sammsg(t, 8, a);
	h.outshort(0, m);
	h.outlong(2, l1);
	h.outshort(6, l2);
	sendsam <- = h;
}
	
outTslS(t, s1, l1: int, s: string)
{
	fprint(ctxt.logfd, "\t\t\t\t\t%s %d %d %s\n", tname[t], s1, l1, s);
	a := array[6 + len array of byte s] of byte;
	h := ref Sammsg(t, len a, a);
	h.outshort(0, s1);
	h.outlong(2, l1);
	h.outcopy(6, array of byte s);
	sendsam <- = h;
}

newname(tag: int)
{
	menuins(0, "dummy", nil, tag);
}

bindname(tag, l: int)
{
	if ((m := whichmenu(tag)) < 0) panic("bindname: whichmenu");
	if ((l = whichtext(l)) < 0) panic("bindname: whichtext");
	if (ctxt.menus[m].text != nil)
		return;		# Already bound
	t := ctxt.texts[l];
	t.tag = tag;
	for (fls := t.flayers; fls != nil; fls = tl fls) (hd fls).tag = tag;
	ctxt.menus[m].text = t;
}

menuins(m: int, s: string, t: ref Text, tag: int)
{
	newmenus := array [len ctxt.menus+1] of ref Menu;
	menu := ref Menu(
		tag,	# tag
		s,	# name
		t	# text
	);
	if (m > 0)
		newmenus[0:] = ctxt.menus[0:m];
	newmenus[m] = menu;
	if (m < len ctxt.menus)
		newmenus[m+1:] = ctxt.menus[m:];	
	ctxt.menus = newmenus;

	samtk->menuins(m, s);
}

menudel(m: int)
{
	if (len ctxt.menus == 0 || m >= len ctxt.menus || ctxt.menus[m].text != nil)
		panic("menudel");
	newmenus := array [len ctxt.menus - 1] of ref Menu;
	newmenus[0:] = ctxt.menus[0:m];
	newmenus[m:] = ctxt.menus[m+1:];
	ctxt.menus = newmenus;
	samtk->menudel(m);
}

outcmd() {
	if(ctxt.work != nil) {
		fl := ctxt.work;
		outTsll(Tworkfile, fl.tag, fl.dot.first, fl.dot.last);
	}
}

hclose(m: int)
{
	i: int;

	# close LAST window of a file
	if((m = whichmenu(m)) < 0) panic("hclose: whichmenu");
	t := ctxt.menus[m].text;
	if (tl t.flayers != nil) panic("hclose: flayers");
	fl := hd t.flayers;
	fl.t = nil;
	for (i = 0; i< len ctxt.flayers; i++)
		if (ctxt.flayers[i] == fl) break;
	if (i == len ctxt.flayers) panic("hclose: ctxt.flayers");
	samtk->chandel(i);
	t.flayers = nil;
	for (i = 0; i< len ctxt.texts; i++)
		if (ctxt.texts[i] == ctxt.menus[m].text) break;
	if (i == len ctxt.texts) panic("hclose: ctxt.texts");
	ctxt.texts[i:] = ctxt.texts[i+1:];
	ctxt.texts = ctxt.texts[:len ctxt.texts - 1];
	ctxt.menus[m].text = nil;
	ctxt.which = nil;
	samtk->focus(hd ctxt.cmd.flayers);
}

close(win, tag: int)
{
	nfls: list of ref Flayer;

	if ((m := whichtext(tag)) < 0) panic("close: text");
	t := ctxt.texts[m];
	if ((m = whichmenu(tag)) < 0) panic("close: menu");
	if (len t.flayers == 1) {
		outTs(Tclose, tag);
		setlock();
		return;
	}
	fl := ctxt.flayers[win];
	nfls = nil;
	for (fls := t.flayers; fls != nil; fls = tl fls)
		if (hd fls != fl) nfls = hd fls :: nfls;
	t.flayers = nfls;
	samtk->chandel(win);
	fl.t = nil;
	samtk->settitle(t, ctxt.menus[m].name);
	ctxt.which = nil;
}

hdelname(m: int)
{
	# close LAST window of a file
	if((m = whichmenu(m)) < 0) panic("hdelname: whichmenu");
	if (ctxt.menus[m].text != nil) panic("hdelname: text");
	ctxt.menus[m:] = ctxt.menus[m+1:];
	ctxt.menus = ctxt.menus[:len ctxt.menus - 1];
	samtk->menudel(m);
	ctxt.which = nil;
}

hdirty(m: int)
{
	if((m = whichmenu(m)) < 0) panic("hdirty: whichmenu");
	if (ctxt.menus[m].text == nil) panic("hdirty: text");
	ctxt.menus[m].text.state |= Samterm->Dirty;
	samtk->settitle(ctxt.menus[m].text, ctxt.menus[m].name);
}

hclean(m: int)
{
	if((m = whichmenu(m)) < 0) panic("hclean: whichmenu");
	if (ctxt.menus[m].text == nil) panic("hclean: text");
	ctxt.menus[m].text.state &= ~Samterm->Dirty;
	samtk->settitle(ctxt.menus[m].text, ctxt.menus[m].name);
}

movename(tag: int, s: string)
{
	i := whichmenu(tag);
	if (i < 0) panic("movename: whichmenu");

	t := ctxt.menus[i].text;

	ctxt.menus[i].text = nil;	# suppress panic in menudel
	menudel(i);

	if(t == ctxt.cmd)
		i = 0;
	else {
		if (len ctxt.menus > 0 && ctxt.menus[0].text == ctxt.cmd)
			i = 1;
		else
			i = 0;
		for(; i < len ctxt.menus; i++) {
			if (s < ctxt.menus[i].name)
				break;
		}
	}
	if (t != nil) samtk->settitle(t, s);
	menuins(i, s, t, tag);
}

hcheck(t: ref Text)
{
	if (t == nil) {
		fprint(ctxt.logfd, "hcheck: no text in menu entry\n");
		return;
	}
	for (fls := t.flayers; fls != nil; fls = tl fls) {
		fl := hd fls;
		scrollto(fl, fl.scope.first);
	}
}

setlock()
{
	ctxt.lock++;
	samtk->allflayers("cursor -bitmap cursor.wait");
}

clrlock()
{
	if (ctxt.lock > 0)
		ctxt.lock--;
	else
		fprint(ctxt.logfd, "lock: wasn't locked\n");
	if (ctxt.lock == 0)
		samtk->allflayers("cursor -default; update");
}

hcut(m, where, howmuch: int)
{
	if((m = whichmenu(m)) < 0) panic("hcut: whichmenu");
	t := ctxt.menus[m].text;
	if (t == nil) panic("hcut -- no text");

#	sctdump(t.sects, "Hcut, before");
	t.nrunes -= howmuch;
	t.sects = sctdelete(t.sects, where, howmuch);
#	sctdump(t.sects, "Hcut, after");
	for (fls := t.flayers; fls != nil; fls = tl fls) {
		fl := hd fls;
		if (where < fl.scope.first) {
			if (where + howmuch <= fl.scope.first)
				fl.scope.first -= howmuch;
			else
				fl.scope.first = where;
		}
		if (where < fl.scope.last) {
			if (where + howmuch <= fl.scope.last)
				fl.scope.last -= howmuch;
			else
				fl.scope.last = where;
		}
	}
}

hgrow(tag, l1, l2: int)
{
	if((m := whichmenu(tag)) < 0) panic("hgrow: whichmenu");
	t := ctxt.menus[m].text;
	grow(t, l1, l2);
}

hdata(m, l: int, s: string)
{
	nr: list of (int, int);

	if((m = whichmenu(m)) < 0) panic("hdata: whichmenu");
	t := ctxt.menus[m].text;
	if (t == nil) panic("hdata -- no text");
	if (s != "") {
		t.sects = sctput(t.sects, l, s);
		updatefls(t, l, s);
	}
	for (nr = nil; requested != nil; requested = tl requested) {
		(r1, r2) := hd requested;
		if (r1 != m || r2 != l)
			nr = (r1, r2) :: nr;
	}
	requested = nr;
	clrlock();
}

hgrowdata(tag, l1, l2: int, s: string)
{
	if((m := whichmenu(tag)) < 0) panic("hgrow: whichmenu");
	t := ctxt.menus[m].text;
	if (t == nil) panic("hdata -- no text");
	grow(t, l1, l2);
	t.sects = sctput(t.sects, l1, s);
	updatefls(t, l1, s);
}

hsetdot(m, l1, l2: int)
{
	if((m = whichmenu(m)) < 0) panic("hsetdot: whichmenu");
	t := ctxt.menus[m].text;
	if (t == nil || t.flayers == nil) panic("hsetdot -- no text");
	samtk->setdot(hd t.flayers, l1, l2);
}

hcurrent(tag: int)
{
	if ((i := whichmenu(tag)) < 0) panic("hcurrent: whichmenu");
	if (ctxt.menus[i].text == nil) {
		n := startfile(tag);
		ctxt.menus[i].text = ctxt.texts[n];
		if (ctxt.menus[i].name != nil)
			samtk->settitle(ctxt.texts[n], ctxt.menus[i].name);
	}
	ctxt.work = hd ctxt.menus[i].text.flayers;
}

hmoveto(m, l: int)
{
	if((m = whichmenu(m)) < 0) panic("hmoveto: whichmenu");
	t := ctxt.menus[m].text;
	fl := hd t.flayers;
	if (fl.scope.first <= l &&
	   (l < fl.scope.last || fl.scope.last == fl.scope.first))
		return;
	(n, p) := sctrevcnt(t.sects, l, fl.lines/2);
#	fprint(ctxt.logfd, "hmoveto: (n, p) = (%d, %d)\n", n, p);
	if (n < 0) {
		outTsll(Torigin, t.tag, l, fl.lines/2);
		setlock();
		return;
	}
	scrollto(fl, p);
}

startcmdfile()
{
	t := ctxt.tag++;
	n := newtext(t, 1);
	ctxt.cmd = ctxt.texts[n];
	outTv(Tstartcmdfile, big t);
}

startnewfile()
{
	t := ctxt.tag++;
	n := newtext(t, 0);
	outTv(Tstartnewfile, big t);
}

startfile(tag: int): int
{
	n := newtext(tag, 0);
	outTv(Tstartfile, big tag);
	setlock();
	return n;
}

horigin(m, l: int)
{
	if((m = whichmenu(m)) < 0) panic("hmoveto: whichmenu");
	t := ctxt.menus[m].text;
	fl := hd t.flayers;
	scrollto(fl, l);
	clrlock();
}

scrollto(fl: ref Flayer, where: int)
{
	s: string;
	n: int;

	tag := fl.tag;
	if ((i := whichtext(tag)) < 0) panic("scrollto: whichtext");
	t := ctxt.texts[i];
	
	samtk->flclear(fl);
	(n, s) = sctgetlines(t.sects, where, fl.lines);
	fl.scope.first = where;
	fl.scope.last = where + len s;
	if (s != "")
		samtk->flinsert(fl, where, s);
	if (n == 0) {
		samtk->setscrollbar(t, fl);
	} else {
		(h, l) := scthole(t, fl.scope.last);
		fl.scope.last = h;
		if (l > 0)
			outrequest(tag, h, l);
		else
			if (fl.scope.first > t.nrunes) {
				fl.scope.first = t.nrunes;
				fl.scope.last = t.nrunes;
				samtk->setscrollbar(t, fl);
			}
	}
}

scthole(t: ref Text, f: int): (int, int)
{
	p := 0;
	h := -1;
	l := 0;
	for (scts := t.sects; scts != nil; scts = tl scts) {
		sct := hd scts;
		nr := sct.nrunes;
		nt := len sct.text;
		if (h >= 0) {
			if (sct.text == "") {
				l += nr;
				if (l >= 512) return (h,512);
			} else
				return (h,l);
		}
		if (h < 0 && f < nr) {
			if (nt < nr) {
				if (f < nt) {
					h = p + nt;
					l = nr - nt;
				} else {
					h = p + f;
					l = nr - f;
				}
				if (l >= 512) return (h,512);
			}
		}
		p += sct.nrunes;
		f -= sct.nrunes;
	}
	if (h == -1) return (p, 0);
	return (h, l);
}

# return (x, p): x = -1: p -> hole; x = 0: p -> line n; x > 0: p -> eof
sctlinecount(t: ref Text, pos, n: int): (int, int)
{
	i: int;

	p := 0;
	for (scts := t.sects; scts != nil; scts = tl scts) {
		sct := hd scts;
		nr := sct.nrunes;
		nt := len sct.text;
		if (pos < nr) {
			if (pos > 0) i = pos; else i = 0;
			while (i < nt) {
				if (sct.text[i++] == '\n') n--;
				if (n == 0) return (0, p + i);
			}
			if (nt < nr) return (-1, p + nt);
		}
		p += sct.nrunes;
		pos -= sct.nrunes;
	}
	return (n, p);
}

sctrevcnt(scts: list of ref Section, pos, n: int): (int, int)
{
	if (scts == nil) return (n, 0);
	sct := hd scts;
	scts = tl scts;
	nt := len sct.text;
	nr := sct.nrunes;
	if (pos >= nr) {
		(n, pos) = sctrevcnt(scts, pos - nr, n);
		pos += nr;
	}
	if (n > 0) {
		if (nt < nr && pos > nt)
			return(-1, pos);
		for (i := pos-1; i >= 0; i--) {
			if (sct.text[i] == '\n') n--;
			if (n == 0) break;
		}
		return (n, i + 1);	
	}
	return (n, pos);
}

insertfls(t: ref Text, l: int, s: string)
{
	for (fls := t.flayers; fls != nil; fls = tl fls) {
		fl := hd fls;
		if (l < fl.scope.first || l > fl.scope.last) continue;
		samtk->flinsert(fl, l, s);
		samtk->setscrollbar(t, fl);
		fl.scope.last += len s;
	}
}

updatefls(t: ref Text, l: int, s: string)
{
	for (fls := t.flayers; fls != nil; fls = tl fls) {
		fl := hd fls;
		if (l < fl.scope.first || l > fl.scope.last) continue;
		samtk->flinsert(fl, l, s);
		(x, p) := sctlinecount(t, fl.scope.first, fl.lines);
		fl.scope.last = p;
		if (x >= 0) {
			if (p > l + len s) {
				samtk->flinsert(fl, l + len s,
					sctget(t.sects, l + len s, p));
			}
			if (x == 0)
				samtk->fldelexcess(fl);
		} else {
			(h1, h2) := scthole(t, l);
			fl.scope.last = h1;
			if (h2 > 0) {
				outrequest(t.tag, h1, h2);
				continue;
			} else {
				panic("Can't happen ??");
			}
		}
		samtk->setscrollbar(t, fl);
	}
}

outrequest(tag, h1, h2: int) {
	for (l := requested; l != nil; l = tl l) {
		(r1, r2) := hd l;
		if (r1 == tag && r2 == h1) return;
	}
	outTsls(Trequest, tag, h1, h2);
	requested = (tag, h1) :: requested;
	setlock();
}

deletefls(t: ref Text, pos, nbytes: int)
{
	for (fls := t.flayers; fls != nil; fls = tl fls) {
		fl := hd fls;
		if (pos >= fl.scope.last) continue;
		if (pos + nbytes <= fl.scope.first || pos >= fl.scope.last) {
			fl.scope.first -= nbytes;
			fl.scope.last -= nbytes;
			continue;
		}
		samtk->fldelete(fl, pos, pos + nbytes);
		(x, p) := sctlinecount(t, fl.scope.first, fl.lines);
		if (x >= 0 && p > fl.scope.last) {
			samtk->flinsert(fl, fl.scope.last,
				sctget(t.sects, fl.scope.last, p));
			fl.scope.last = p;
		} else {
			fl.scope.last = p;
			(h1, h2) := scthole(t, fl.scope.last);
			if (h2 > 0)
				outrequest(t.tag, h1, h2);
		}
		samtk->setscrollbar(t, fl);
	}
}

contract(s: string): string
{
	if (len s < 32)
		cs := s;
	else
		cs = s[0:16] + " ... " + s[len s - 16:];
	for (i := 0; i < len cs; i++)
		if (cs[i] == '\n') cs[i] = '\u008a';
	return cs;
}

cleanout()
{
	if ((fl := ctxt.which) == nil) return;
	if ((i := whichtext(fl.tag)) < 0) panic("cleanout: whichtext");
	t := ctxt.texts[i];

	if (fl.typepoint >= 0 && fl.dot.first > fl.typepoint) {
		s := sctget(t.sects, fl.typepoint, fl.dot.first);
		outTslS(Samstub->Ttype, fl.tag, fl.typepoint, s);
		t.state &= ~Samterm->LDirty;
	}
	fl.typepoint = -1;
}

newtext(tag, tp: int): int
{
	n := len ctxt.texts;
	t := ref Text(
		tag,					# tag
		0,					# lock
		samtk->newflayer(tag, tp) :: nil,	# flayers
		0,					# nrunes
		nil,					# sects
		0					# state
	);
	texts := array [n + 1] of ref Text;
	texts[0:] = ctxt.texts;
	texts[n] = t;
	ctxt.texts = texts;
	samtk->newcur(t, hd t.flayers);
	return n;
}

keypress(key: string)
{
	# Find text and flayer
	fl := ctxt.which;
	tag := fl.tag;
	if ((i := whichtext(tag)) < 0) panic("keypress: whichtext");
	t := ctxt.texts[i];

	if (fl.dot.last != fl.dot.first) {
		cut(t, fl);
	}

	case (key) {
	"\b" =>
		if (t.nrunes == 0 || fl.dot.first == 0)
			return;
		fl.dot.first--;
		if (fl.typepoint >= 0 && fl.dot.first >= fl.typepoint) {
			t.nrunes -= fl.dot.last - fl.dot.first;
			t.sects = sctdelete(t.sects, fl.dot.first, fl.dot.last - fl.dot.first);
			deletefls(t, fl.dot.first, fl.dot.last - fl.dot.first);
			if (fl.dot.first == fl.typepoint) {
				fl.typepoint = -1;
				t.state &= ~Samterm->LDirty;
				if ((i = whichmenu(tag)) < 0)
					panic("keypress: whichmenu");
				samtk->settitle(t, ctxt.menus[i].name);
			}
		} else {
			cut(t, fl);
		}
	* =>
		if (fl.typepoint < 0) {
			fl.typepoint = fl.dot.first;
			t.state |= Samterm->LDirty;
			if ((i = whichmenu(tag)) < 0)
				panic("keypress: whichmenu");
			samtk->settitle(t, ctxt.menus[i].name);
		}
		if (fl.dot.first > t.nrunes)
			panic("keypress -- cursor > file len");
		t.sects = sctmakeroom(t.sects, fl.dot.first, len key);
		t.nrunes += len key;
		t.sects = sctput(t.sects, fl.dot.first, key);
		insertfls(t, fl.dot.first, key);
		f := fl.dot.first + len key;
		samtk->setdot(fl, f, f);
		if (key == "\n") {
			if (f >= fl.scope.last) {
				(n, p) := sctrevcnt(t.sects, f-1, 2*fl.lines/3);
				if (n < 0) {
					outTsll(Torigin, t.tag, f-1, 2*fl.lines/3);
					setlock();
				} else {
					scrollto(fl, p);
				}
			}
			if (t == ctxt.cmd && fl.dot.last == t.nrunes) {
				outcmd();
				setlock();
			}
			cleanout();
		}
	}
	return;
}

cut(t: ref Text, fl: ref Flayer)
{
	if (fl.typepoint >= 0) panic("cut: typepoint");
	outTsll(Tcut, fl.tag, fl.dot.first, fl.dot.last);
	t.nrunes -= fl.dot.last - fl.dot.first;
	t.sects = sctdelete(t.sects, fl.dot.first, fl.dot.last - fl.dot.first);
	deletefls(t, fl.dot.first, fl.dot.last - fl.dot.first);
}

paste(t: ref Text, fl: ref Flayer)
{
	if (fl.typepoint >= 0) panic("paste: typepoint");
	if (snarflen == 0) return;
	if (fl.dot.first < fl.dot.last) cut(t, fl);
	outTsl(Tpaste, fl.tag, fl.dot.first);
}

snarf(nil: ref Text, fl: ref Flayer)
{
	if (fl.typepoint >= 0) panic("snarf: typepoint");
	if (fl.dot.first == fl.dot.last) return;
	snarflen = fl.dot.last - fl.dot.first;
	outTsll(Tsnarf, fl.tag, fl.dot.first, fl.dot.last);
}

look(nil: ref Text, fl: ref Flayer)
{
	if (fl.typepoint >= 0) panic("look: typepoint");
	outTsll(Tlook, fl.tag, fl.dot.first, fl.dot.last);
	setlock();
}

send(nil: ref Text, fl: ref Flayer)
{
	if (fl.typepoint >= 0) panic("send: typepoint");
	outcmd();
	outTsll(Tsend, fl.tag, fl.dot.first, fl.dot.last);
	setlock();
}

search(nil: ref Text, fl: ref Flayer)
{
	if (fl.typepoint >= 0) panic("search: typepoint");
	outcmd();
	outT0(Tsearch);
	setlock();
}

zerox(t: ref Text)
{
	fl := samtk->newflayer(t.tag, ctxt.cmd == t);
	t.flayers = fl :: t.flayers;
	m := whichmenu(t.tag);
	samtk->settitle(t, ctxt.menus[m].name);
	samtk->newcur(t, fl);
	scrollto(fl, 0);
}

sctget(scts: list of ref Section, p1, p2: int): string
{
	while (scts != nil) {
		sct := hd scts; scts = tl scts;
		ln := len sct.text;
		if (p1 < sct.nrunes) {
			if (ln < sct.nrunes && p2 > ln) {
				sctdump(scts, "panic");
				panic("sctget - asking for a hole");
			}
			if (p2 > sct.nrunes) {
				s := sct.text[p1:];
				return s + sctget(scts, 0, p2 - ln);
			}
			return sct.text[p1:p2];
		}
		p1 -= sct.nrunes;
		p2 -= sct.nrunes;
	}
	return "";
}

sctgetlines(scts: list of ref Section, p, n: int): (int, string)
{
	s := "";
	while (scts != nil) {
		sct := hd scts; scts = tl scts;
		ln := len sct.text;
		if (p < sct.nrunes) {
			if (p > ln) return (n, s);
			if (p > 0) b := p; else b = 0;
			for (i := b; i < ln && n > 0;   ) {
				if (sct.text[i++] == '\n') n--;
			}
			if ( i > b)
				s = s + sct.text[b:i];
			if (n == 0 || ln < sct.nrunes) return (n, s);
		}
		p -= sct.nrunes;
	}
	return (n, s);
}

sctput(scts: list of ref Section, pos: int, s: string): list of ref Section
{
	# There should be a hole to receive text
	if (scts == nil  && s != "") panic("sctput: scts is nil\n");
	sct := hd scts;
	l := len sct.text;
	if (sct.nrunes <= pos) {
		return sct :: sctput(tl scts, pos-sct.nrunes, s);
	}
	if (pos < l) {
		sctdump(scts, "panic");
		panic("sctput: overwriting");
	}
	if (pos == l) {
		if (sct.nrunes < l + len s) {
			sct.text += s[:sct.nrunes-l];
			return sct :: sctput(tl scts, 0, s[sct.nrunes-l:]);
		} 
		sct.text += s;	
		return sct :: tl scts;
	}
	nrunes := sct.nrunes;
	sct.nrunes = pos;
	if (nrunes < pos + len s)
		return	sct ::
			ref Section(nrunes-pos, s[:nrunes-pos]) ::
			sctput(tl scts, 0, s[nrunes-pos:]);
	return sct :: ref Section(nrunes-pos, s) :: tl scts;
}

sctmakeroom(scts: list of ref Section, pos: int, l: int): list of ref Section
{
	if (scts == nil) {
		if (pos) panic("sctmakeroom: beyond end of sections");
		return ref Section(l, nil) :: nil;
	}
	sct := hd scts;
	if (sct.nrunes < pos)
		return sct :: sctmakeroom(tl scts, pos-sct.nrunes, l);
	if (len sct.text <= pos) {
		# just add to the hole at end of section
		sct.nrunes += l;
		return sct :: tl scts;
	}
	if (pos == 0) {
		# text is non-nil!
		bsct := ref Section(l, nil);
		return bsct :: scts;
	}
	bsct := ref Section(pos + l, sct.text[0:pos]);
	esct := ref Section(sct.nrunes-pos, sct.text[pos:]);
	return bsct :: esct :: tl scts;
}

sctdelete(scts: list of ref Section, start, nbytes: int): list of ref Section
{
	if (nbytes == 0) return scts;
	if (scts == nil) panic("sctdelete: at eof");
	sct := hd scts;
	scts = tl scts;
	nrunes := sct.nrunes;
	if (start + nbytes < len sct.text) {
		sct.text = sct.text[0:start] + sct.text[start+nbytes:];
		sct.nrunes -= nbytes;
		return sct :: scts;
	}
	if (start < nrunes) {
		if (start > 0) {
			if (start < len sct.text)
				sct.text = sct.text[0:start];
			if (start + nbytes <= nrunes) {
				sct.nrunes -= nbytes;
				return sct :: scts;
			}
			sct.nrunes = start;
			return sct :: sctdelete(scts, 0, nbytes-nrunes+start);
		}
		if (nbytes < nrunes) {
			sct.text = "";
			sct.nrunes -= nbytes;
			return sct :: scts;
		}
		return sctdelete(scts, 0, nbytes - nrunes);
	}
	return sct :: sctdelete(scts, start - nrunes, nbytes);
}

grow(t: ref Text, at, l: int)
{
#	sctdump(t.sects, "grow, before");
	t.sects = sctmakeroom(t.sects, at, l);
	t.nrunes += l;
#	sctdump(t.sects, "grow, after");
	for (fls := t.flayers; fls != nil; fls = tl fls) {
		fl := hd fls;
		if (at < fl.scope.first) fl.scope.first += l;
		if (at < fl.scope.last) fl.scope.last += l;
	}
}

findhole(t: ref Text): (int, int)
{
	for (fls := t.flayers; fls != nil; fls = tl fls) {
		(h, l) := scthole(t, (hd fls).scope.first);
		if (l > 0) return (h, l);
	}
	return (0, 0);
}

sctdump(scts: list of ref Section, s: string)
{
	fprint(ctxt.logfd, "Sctdump: %s\n", s);
	p := 0;
	while (scts != nil) {
		sct := hd scts; scts = tl scts;
		fprint(ctxt.logfd, "\tsct@%4d len=%4d len txt=%4d: %s\n",
			p, sct.nrunes, len sct.text, contract(sct.text));
		p += sct.nrunes;
	}
	fprint(ctxt.logfd, "\tend@%4d\n", p);
}