#
# Copyright © 1998 Vita Nuova Limited.  All rights reserved.
#

implement Miniterm;

include "sys.m";
	sys: Sys;
	print, fprint, sprint, read: import sys;
include "draw.m";
	draw: Draw;
include "tk.m";
	tk: Tk;
include "tkclient.m";
	tkclient: Tkclient;

include "miniterm.m";

Miniterm: module
{
	init:		fn(ctxt: ref Draw->Context, argv: list of string);

};

pgrp: 		int 			= 0;
debug:		array of int	= array[256] of {* => 0};
stderr:		ref Sys->FD;

# Minitel terminal identification request - reply sequence
TERMINALID1 := array [] of {
	byte SOH,
	byte 'S', byte 'X', byte '1', byte 'H', byte 'N',
	byte EOT
};
TERMINALID2 := array [] of {
	byte SOH,
	byte 'C', byte 'g', byte '1',
	byte EOT
};

# Minitel module identifiers
Mscreen, Mmodem, Mkeyb, Msocket, Nmodule: con iota;
Pscreen, Pmodem, Pkeyb, Psocket: con (1 << iota);
Modname := array [Nmodule] of {
	Mscreen		=> "S",
	Mmodem		=> "M",
	Mkeyb 		=> "K",
	Msocket		=> "C",
	*			=> "?",
};

# attributes common to all modules
Module: adt {
	path:		int;					# bitset to connected modules
	disabled:	int;
};

# A BufChan queues events from the terminal to the modules
BufChan: adt {
	path:		int;					# id bit
	ch:		chan of ref Event;		# set to `in' or `dummy' channel 
	ev:		ref Event;				# next event to send
	in:		chan of ref Event;		# real channel for Events to the device
	q:		array of ref Event;		# subsequent events to send
};

# holds state information for the minitel `protocol` (chapter 6)
PState: adt {
	state:		int;
	arg:			array of int;		# up to 3 arguments: X,Y,Z
	nargs:		int;				# expected number of arguments
	n:			int;				# progress
	skip:			int;				# transparency; bytes to skip
};
PSstart, PSesc, PSarg: con iota;	# states

# Terminal display modes
Videotex, Mixed, Ascii,

# Connection methods
Direct, Network,

# Terminal connection states
Local, Connecting, Online,

# Special features
Echo
	: con (1 << iota);

Terminal: adt {
	in:		chan of ref Event;
	out:		array of ref BufChan;	# buffered output to the minitel modules

	mode:	int;					# display mode
	state:	int;					# connection state
	spec:	int;					# special features
	connect:	int;					# Direct, or Network
	toplevel:	ref Tk->Toplevel;
	cmd:		chan of string;			# from Tk
	proto:	array of ref PState;		# minitel protocol state
	netaddr:	string;				# network address to dial
	buttonsleft: int;				# display buttons on the LHS (40 cols)
	terminalid: array of byte;			# ENQROM response
	kbctl:	chan of string;			# softkeyboard control
	kbmode:	string;				# softkeyboard mode

	init:		fn(t: self ref Terminal, toplevel: ref Tk->Toplevel, connect: int);
	run:		fn(t: self ref Terminal, done: chan of int);
	reset:	fn(t: self ref Terminal);
	quit:		fn(t: self ref Terminal);
	layout:	fn(t: self ref Terminal, cols: int);
	setkbmode:	fn(t: self ref Terminal, tmode: int);
};

include "arg.m";
include "event.m";
include "event.b";

include "keyb.b";
include "modem.b";
include "socket.b";
include "screen.b";

K:		ref Keyb;
M:		ref Modem;
C:		ref Socket;
S:		ref Screen;
T:		ref Terminal;
Modules:	array of ref Module;


init(ctxt: ref Draw->Context, argv: list of string)
{
	s: string;
	netaddr: string = nil;

	sys = load Sys Sys->PATH;
	tk = load Tk Tk->PATH;
	tkclient = load Tkclient Tkclient->PATH;
	tkclient->init();
	draw = load Draw Draw->PATH;
	stderr = sys->fildes(2);
	pgrp = sys->pctl(Sys->NEWPGRP|Sys->FORKNS, nil);

	arg := load Arg Arg->PATH;
	arg->init(argv);
	arg->setusage("miniterm [netaddr]");
	while((c := arg->opt()) != 0){
		case c {
		'D' =>
			s = arg->earg();
			for(i := 0; i < len s; i++){
				c = s[i];
				if(c < len debug)
					debug[c] += 1;
			}
		* =>
			arg->usage();
		}
	}
	argv = arg->argv();
	if(len argv > 0) {
		netaddr = hd argv;
		argv = tl argv;
	}

	if(argv != nil)
		arg->usage();
	arg = nil;

	# usage:	miniterm modem[!init[!number]]
	#	or	miniterm tcp!a.b.c.d
	connect: int;
	initstr := dialstr := string nil;
	if(netaddr == nil)
		netaddr = "tcp!pdc.minitelfr.com!513";	# gateway
	(nil, words) := sys->tokenize(netaddr, "!");
	if(len words == 0) {
		connect = Direct;
		words = "modem" :: nil;
	}
	if(hd words == "modem") {
		connect = Direct;
		words = tl words;
		if(words != nil) {
			initstr = hd words;
			words = tl words;
			if(words != nil)
				dialstr = hd words;
		}
		if(initstr == "*")
			initstr = nil;
		if(dialstr == "*")
			dialstr = nil;
	} else {
		connect = Network;
		dialstr = netaddr;
	}

	T = ref Terminal;
	K = ref Keyb;
	M = ref Modem;
	C = ref Socket;
	S = ref Screen;
	Modules = array [Nmodule] of {
		Mscreen	=> S.m,
		Mmodem	=> M.m,
		Mkeyb 	=> K.m,
		Msocket	=> C.m,
	};

	toplevel := tk->toplevel(ctxt.display, "");
	inittk(toplevel, connect);

	T.init(toplevel, connect);
	K.init(toplevel);
	M.init(connect, initstr, dialstr);
	C.init();
	case connect {
	Direct =>
		S.init(ctxt, Rect((0,0), (640,425)), Rect((0,0), (640,425)));
	Network =>
		S.init(ctxt, Rect((0,0), (596,440)), Rect((0,50), (640,350)));
	}

	done := chan of int;
	spawn K.run();
	spawn M.run();
	spawn C.run();
	spawn S.run();
	spawn T.run(done);
	<- done;

	# now tidy up
	K.quit();
	M.quit();
	C.quit();
	S.quit();
	T.quit();
}

# the keyboard module handles keypresses and focus
BTN40x25: con "-height 24 -font {/fonts/lucidasans/unicode.6.font}";
BTNCTL: con "-width 60 -height 20 -font {/fonts/lucidasans/unicode.7.font}";
BTNMAIN: con "-width 80 -height 20 -font {/fonts/lucidasans/unicode.7.font}";

tkinitbs := array[] of {
	"button .cxfin -text {Cx/Fin} -command {send keyb skey Connect}",
	"button .done -text {Quitter} -command {send keyb skey Exit}",
	"button .hup -text {Raccr.} -command {send term hangup}",
	"button .somm -text {Somm.} -command {send keyb skey Index}",
	"button .guide -text {Guide} -command {send keyb skey Guide}",
	"button .annul -text {Annul.} -command {send keyb skey Cancel}",
	"button .corr -text {Corr.} -command {send keyb skey Correct}",
	"button .retour -text {Retour} -command {send keyb skey Previous}",
	"button .suite -text {Suite} -command {send keyb skey Next}",
	"button .repet -text {Répét.} -command {send keyb skey Repeat}",
	"button .envoi -text {Envoi} -command {send keyb skey Send}",
	"button .play -text {P} -command {send term play}",
#	"button .db -text {D} -command {send term debug}" ,
	"button .kb -text {Clavier} -command {send term keyboard}",
	"button .move -text {<-} -command {send term buttonsleft} " + BTN40x25,
};

tkinitdirect := array [] of {
	". configure -background black -height 480 -width 640",

	".cxfin configure " + BTNCTL,
	".hup configure " + BTNCTL,
	".done configure " + BTNCTL,
	".somm configure " + BTNMAIN,
	".guide configure " + BTNMAIN,
	".annul configure " + BTNMAIN,
	".corr configure " + BTNMAIN,
	".retour configure " + BTNMAIN,
	".suite configure " + BTNMAIN,
	".repet configure " + BTNMAIN,
	".envoi configure " + BTNMAIN,
#	".play configure " + BTNCTL,
#	".db configure " + BTNCTL,
	".kb configure " + BTNCTL,

	"canvas .c -height 425 -width 640 -background black",
	"bind .c <Configure> {send term resize}",
	"bind .c <Key> {send keyb key %K}",
	"bind .c <FocusIn> {send keyb focusin}",
	"bind .c <FocusOut> {send keyb focusout}",
	"bind .c <ButtonRelease> {focus .c; send keyb click %x %y}",
	"frame .k -height 55 -width 640 -background black",
	"pack propagate .k no",
	"frame .klhs -background black",
	"frame .krhs -background black",
	"frame .krows -background black",
	"frame .k1 -background black",
	"frame .k2 -background black",
	"pack .cxfin -in .klhs -anchor w -pady 4",
	"pack .hup -in .klhs -anchor w",
	"pack .somm .annul .retour .repet -in .k1 -side left -padx 2",
	"pack .guide .corr .suite .envoi -in .k2 -side left -padx 2",
	"pack .kb -in .krhs -anchor e -pady 4",
	"pack .done -in .krhs -anchor e",
	"pack .k1 -in .krows -pady 4",
	"pack .k2 -in .krows",
	"pack .klhs .krows .krhs -in .k -side left -expand 1 -fill x",
	"pack .c .k",
	"focus .c",
	"update",
};

tkinitip := array [] of {
	". configure -background black -height 440 -width 640",

	# ip 40x25 mode support
	"canvas .c40 -height 440 -width 596 -background black",
	"bind .c40 <Configure> {send term resize}",
	"bind .c40 <Key> {send keyb key %K}",
	"bind .c40 <FocusIn> {send keyb focusin}",
	"bind .c40 <FocusOut> {send keyb focusout}",
	"bind .c40 <ButtonRelease> {focus .c40; send keyb click %x %y}",
	"frame .k -height 427 -width 44 -background black",
	"frame .gap1 -background black",
	"frame .gap2 -background black",
	"pack propagate .k no",

	# ip 80x25 mode support
	"frame .padtop -height 50",
	"canvas .c80 -height 300 -width 640 -background black",
	"bind .c80 <Configure> {send term resize}",
	"bind .c80 <Key> {send keyb key %K}",
	"bind .c80 <FocusIn> {send keyb focusin}",
	"bind .c80 <FocusOut> {send keyb focusout}",
	"bind .c80 <ButtonRelease> {focus .c80; send keyb click %x %y}",
	"frame .k80 -height 90 -width 640 -background black",
	"pack propagate .k80 no",
	"frame .klhs -background black",
	"frame .krows -background black",
	"frame .krow1 -background black",
	"frame .krow2 -background black",
	"frame .krhs -background black",
	"pack .krow1 .krow2 -in .krows -pady 2",
	"pack .klhs -in .k80 -side left",
	"pack .krows -in .k80 -side left -expand 1",
	"pack .krhs -in .k80 -side left",
};

tkip40x25show := array [] of {
	".cxfin configure " + BTN40x25,
	".hup configure " + BTN40x25,
	".done configure " + BTN40x25,
	".somm configure " + BTN40x25,
	".guide configure " + BTN40x25,
	".annul configure " + BTN40x25,
	".corr configure " + BTN40x25,
	".retour configure " + BTN40x25,
	".suite configure " + BTN40x25,
	".repet configure " + BTN40x25,
	".envoi configure " + BTN40x25,
	".play configure " + BTN40x25,
#	".db configure " + BTN40x25,
	".kb configure " + BTN40x25,
	"pack .cxfin -in .k -side top -fill x",
	"pack .gap1 -in .k -side top -expand 1",
	"pack .guide .repet .somm .annul .corr .retour .suite .envoi -in .k -side top -fill x",
	"pack .gap2 -in .k -side top -expand 1",
	"pack .done .hup .kb .move -in .k -side bottom -pady 2 -fill x",
#	"pack .db -in .k -side bottom",
};

tkip40x25lhs := array [] of {
	".move configure -text {->} -command {send term buttonsright}",
	"pack .k .c40 -side left",
	"focus .c40",
	"update",
};

tkip40x25rhs := array [] of {
	".move configure -text {<-} -command {send term buttonsleft}",
	"pack .c40 .k -side left",
	"focus .c40",
	"update",
};

tkip40x25hide := array [] of {
	"pack forget .k .c40",
};

tkip80x25show := array [] of {
	".cxfin configure " + BTNCTL,
	".hup configure " + BTNCTL,
	".done configure " + BTNCTL,
	".somm configure " + BTNMAIN,
	".guide configure " + BTNMAIN,
	".annul configure " + BTNMAIN,
	".corr configure " + BTNMAIN,
	".retour configure " + BTNMAIN,
	".suite configure " + BTNMAIN,
	".repet configure " + BTNMAIN,
	".envoi configure " + BTNMAIN,
#	".play configure " + BTNCTL,
#	".db configure " + BTNCTL,
	".kb configure " + BTNCTL,

	"pack .cxfin .hup -in .klhs -anchor w -pady 2",
	"pack .somm .annul .retour .repet -in .krow1 -side left -padx 2",
	"pack .guide .corr .suite .envoi -in .krow2 -side left -padx 2",
	"pack .done .kb -in .krhs -anchor e -pady 2",
	"pack .padtop .c80 .k80 -side top",
	"focus .c80",
	"update",
};

tkip80x25hide := array [] of {
	"pack forget .padtop .c80 .k80",
};

inittk(toplevel: ref Tk->Toplevel, connect: int)
{
	tkcmds(toplevel, tkinitbs);
	if(connect == Direct)
		tkcmds(toplevel, tkinitdirect);
	else
		tkcmds(toplevel, tkinitip);
}

Terminal.layout(t: self ref Terminal, cols: int)
{
	if(t.connect == Direct)
		return;
	if(cols == 80) {
		tkcmds(t.toplevel, tkip40x25hide);
		tkcmds(t.toplevel, tkip80x25show);
	} else {
		tkcmds(t.toplevel, tkip80x25hide);
		tkcmds(t.toplevel, tkip40x25show);
		if (t.buttonsleft)
			tkcmds(t.toplevel, tkip40x25lhs);
		else
			tkcmds(t.toplevel, tkip40x25rhs);
	}
}

Terminal.init(t: self ref Terminal, toplevel: ref Tk->Toplevel, connect: int)
{
	t.in = chan of ref Event;
	t.proto = array [Nmodule] of {
		Mscreen	=>	ref PState(PSstart, array [] of {0,0,0}, 0, 0, 0),
		Mmodem	=>	ref PState(PSstart, array [] of {0,0,0}, 0, 0, 0),
		Mkeyb	=>	ref PState(PSstart, array [] of {0,0,0}, 0, 0, 0),
		Msocket	=>	ref PState(PSstart, array [] of {0,0,0}, 0, 0, 0),
	};

	t.toplevel = toplevel;
	t.connect = connect;
	if (t.connect == Direct)
		t.spec = 0;
	else
		t.spec = Echo;
	t.cmd = chan of string;
	tk->namechan(t.toplevel, t.cmd, "term");		# Tk -> terminal
	t.state = Local;
	t.buttonsleft = 0;
	t.kbctl = nil;
	t.kbmode = "minitel";
	t.reset();
}

Terminal.reset(t: self ref Terminal)
{
	t.mode = Videotex;
}

Terminal.run(t: self ref Terminal, done: chan of int)
{
	t.out = array [Nmodule] of {
		Mscreen	=> ref BufChan(Pscreen, nil, nil, S.in, array [0] of ref Event),
		Mmodem	=> ref BufChan(Pmodem, nil, nil, M.in, array [0] of ref Event),
		Mkeyb 	=> ref BufChan(Pkeyb, nil, nil, K.in, array [0] of ref Event),
		Msocket	=> ref BufChan(Psocket, nil, nil, C.in, array [0] of ref Event),
	};
	modcount := Nmodule;
	if(debug['P'])
		post(ref Event.Eproto(Pmodem, 0, Cplay, "play", 0,0,0));
Evloop:
	for(;;) {
		ev: ref Event = nil;
		post(nil);
		alt {
		# recv message from one of the modules
		ev =<- t.in =>
			if(ev == nil) {			# modules ack Equit with nil
				if(--modcount == 0)
					break Evloop;
				continue;
			}
			pick e := ev {
			Equit =>		# close modules down
				post(ref Event.Equit(Pscreen|Pmodem|Pkeyb|Psocket,0));
				continue;
			}

			eva := protocol(ev);
			while(len eva > 0) {
				post(eva[0]);
				eva = eva[1:];
			}

		# send message to `plumbed' modules
		t.out[Mscreen].ch	<- = t.out[Mscreen].ev	=>
			t.out[Mscreen].ev = nil;
		t.out[Mmodem].ch	<- = t.out[Mmodem].ev	=>
			t.out[Mmodem].ev = nil;
		t.out[Mkeyb].ch		<- = t.out[Mkeyb].ev		=>
			t.out[Mkeyb].ev = nil;
		t.out[Msocket].ch	<- = t.out[Msocket].ev	=>
			t.out[Msocket].ev = nil;

		# recv message from Tk
		cmd := <- t.cmd =>
			(n, word) := sys->tokenize(cmd, " ");
			if(n >0)
				case hd word {
				"resize" =>	;
				"play" => # for testing only
					post(ref Event.Eproto(Pmodem, Mmodem, Cplay, "play", 0,0,0));
				"keyboard" =>
					if (t.kbctl == nil) {
						e: string;
						(e, t.kbctl) = kb(t);
						if (e != nil)
							sys->print("cannot start keyboard: %s\n", e);
					} else
						t.kbctl <- = "click";
				"hangup" =>
					if(T.state == Online || T.state == Connecting)
						post(ref Event.Eproto(Pmodem, 0, Cdisconnect, "",0,0,0));
				"buttonsleft" =>
					tkcmds(t.toplevel, tkip40x25lhs);
					t.buttonsleft = 1;
					if(S.image != nil)
						draw->(S.image.origin)(Point(0,0), Point(44, 0));
					if (t.kbctl != nil)
						t.kbctl <- = "fg";
				"buttonsright" =>
					tkcmds(t.toplevel, tkip40x25rhs);
					t.buttonsleft = 0;
					if(S.image != nil)
						draw->(S.image.origin)(Point(0,0), Point(0, 0));
					if (t.kbctl != nil)
						t.kbctl <- = "fg";
				"debug" =>
					debug['s'] ^= 1;
					debug['m'] ^= 1;
				}
		}

	}
	if (t.kbctl != nil)
		t.kbctl <- = "quit";
	t.kbctl = nil;
	done <-= 0;
}

kb(t: ref Terminal): (string, chan of string)
{
	s := chan of string;
	spawn dokb(t, s);
	e := <- s;
	if (e != nil)
		return (e, nil);
	return (nil, s);
}

Terminal.setkbmode(t: self ref Terminal, tmode: int)
{
	case tmode {
	Videotex =>
		t.kbmode = "minitel";
	Mixed or Ascii =>
		t.kbmode = "standard";
	}
	if(t.kbctl != nil) {
		t.kbctl <-= "mode";
		t.kbctl <-= "fg";
	}
}

include "swkeyb.m";
dokb(t: ref Terminal, c: chan of string)
{
	keyboard := load Keyboard Keyboard->PATH;
	if (keyboard == nil) {
		c <- = "cannot load keyboard";
		return;
	}

	kbctl := chan of string;
	(top, m) := tkclient->toplevel(S.ctxt, "", "Keyboard", 0);
	tk->cmd(top, "pack .Wm_t -fill x");
	tk->cmd(top, "update");
	keyboard->chaninit(top, S.ctxt, ".keys", kbctl);
	tk->cmd(top, "pack .keys");

	kbctl <-= t.kbmode ;

	kbon := 1;
	c <- = nil;	# all ok, we are now ready to accept commands

	for (;;) alt {
	mcmd := <- m =>
		if (mcmd == "exit") {
			if (kbon) {
				tk->cmd(top, ". unmap; update");
				kbon = 0;
			}
		} else
			tkclient->wmctl(top, mcmd);
	kbcmd := <- c =>
		case kbcmd {
		"fg" =>
			if (kbon)
				tk->cmd(top, "raise .;update");
		"click" =>
			if (kbon) {
				tk->cmd(top, ". unmap; update");
				kbon = 0;
			} else {
				tk->cmd(top, ". map; raise .");
				kbon = 1;
			}
		"mode" =>
			kbctl <- = t.kbmode;
		"quit"	=>
			kbctl <- = "kill";
			top = nil;
			# ensure tkclient not blocked on a send to us (probably overkill!)
			alt {
				<- m =>	;
				* =>	;
			}
			return;
		}
	}
}


Terminal.quit(nil: self ref Terminal)
{
}

# a minitel module sends an event to the terminal for routing
send(e: ref Event)
{
	if(debug['e'] && e != nil)
		fprint(stderr, "%s: -> %s\n", Modname[e.from], e.str());
	T.in <- = e;
}

# post an event to one or more modules
post(e: ref Event)
{
	i,l: int;
	for(i=0; i<Nmodule; i++) {
		# `ev' is cleared once sent, reload it from the front of `q'
		b: ref BufChan = T.out[i];
		l = len b.q;
		if(b.ev == nil && l != 0) {
			b.ev = b.q[0];
			na := array [l-1] of ref Event;
			na[0:] = b.q[1:];
			b.q = na;
		}
		if (e != nil) {
			if(e.path & b.path) {
				if(debug['e'] > 0) {
					pick de := e {
					* =>
						fprint(stderr, "[%s<-%s] %s\n", Modname[i], Modname[e.from], e.str());
					}
				}
				if(b.ev == nil)		# nothing queued
					b.ev = e;
				else {				# enqueue it
					l = len b.q;
					na := array [l+1] of ref Event;
					na[0:] = b.q[0:];
					na[l] = e;
					b.q = na;
				}
			}
		}
		# set a dummy channel if nothing to send
		if(b.ev == nil)
			b.ch = chan of ref Event;
		else
			b.ch = b.in;
	}
}

# run the terminal protocol
protocol(ev: ref Event): array of ref Event
{
	# Introduced by the following sequences, the minitel protocol can be
	# embedded in any normal data sequence
	# ESC,0x39,X
	# ESC,0x3a,X,Y
	# ESC,0x3b,X,Y,Z
	# ESC,0x61	- cursor position request

	ea := array [0] of ref Event;	# resulting sequence of Events
	changed := 0;				# if set, results are found in `ea'

	pick e := ev {
	Edata =>
		d0 := 0;				# offset of start of last data sequence
		p := T.proto[e.from];
		for(i:=0; i<len e.data; i++) {
			ch := int e.data[i];
#			if(debug['p'])
#				fprint(stderr, "protocol: [%s] %d %ux (%c)\n", Modname[e.from], p.state, ch, ch);
			if(p.skip > 0) {		# in transparency mode
				if(ch == 0 && e.from == Mmodem)	# 5.0
					continue;
				p.skip--;
				continue;
			}
			case p.state {
			PSstart =>
				if(ch == ESC) {
					p.state = PSesc;
					changed = 1;
					if(i > d0)
						ea = eappend(ea, ref Event.Edata(e.path, e.from, e.data[d0:i]));
					d0 = i+1;
				}
			PSesc =>
				p.state = PSarg;
				p.n = 0;
				d0 = i+1;
				changed = 1;
				if(ch >= 16r39 && ch <= 16r3b)	#PRO1,2,3
					p.nargs = ch - 16r39 + 1;
				else if(ch == 16r61)			# cursor position request
					p.nargs = 0;
				else if(ch == ESC) {
					ea = eappend(ea, ref Event.Edata(e.path, e.from, array [] of { byte ESC }));
					p.state = PSesc;
				} else {
					# false alarm, restore as data
					ea = eappend(ea, ref Event.Edata(e.path, e.from, array [] of { byte ESC, byte ch }));
					p.state = PSstart;
				}
			PSarg =>		# expect `nargs' bytes
				d0 = i+1;
				changed =1;
				if(p.n < p.nargs)
					p.arg[p.n++] = ch;
				if(p.n == p.nargs) {
					# got complete protocol sequence
					pe := proto(e.from, p);
					if(pe != nil)
						ea = eappend(ea, pe);
					p.state = PSstart;
				}
			}
		}
		if(changed) {			# some interpretation, results in `ea'
			if(i > d0)
				ea = eappend(ea, ref Event.Edata(e.path, e.from, e.data[d0:i]));
			return ea;
		}
		ev = e;
		return array [] of {ev};
	}
	return array [] of {ev};
}

# append to an Event array
eappend(ea: array of ref Event, e: ref Event): array of ref Event
{
	l := len ea;
	na := array [l+1] of ref Event;
	na[0:] = ea[0:];
	na[l] = e;
	return na;
}

# act on a received protocol sequence
# some sequences are handled here by the terminal and result in a posted reply
# others are returned `inline' as Eproto events with the normal data stream.
proto(from: int, p: ref PState): ref Event
{
	if(debug['p']) {
		fprint(stderr, "PRO%d: %ux", p.nargs, p.arg[0]);
		if(p.nargs > 1)
			fprint(stderr, " %ux", p.arg[1]);
		if(p.nargs > 2)
			fprint(stderr, " %ux", p.arg[2]);
		fprint(stderr, " (%s)\n", Modname[from]);
	}
	case p.nargs {
	0 =>							# cursor position request ESC 0x61
		reply := array [] of { byte US, byte S.pos.y, byte S.pos.x };
		post(ref Event.Edata(Pmodem, from, reply));
	1 =>
		case p.arg[0] {
		PROTOCOLSTATUS =>	;
		ENQROM =>				# identification request
			post(ref Event.Edata(Pmodem, from, T.terminalid));
			if(T.terminalid == TERMINALID1)
				T.terminalid = TERMINALID2;
		SETRAM1 or SETRAM2 =>	;
		FUNCTIONINGSTATUS =>		# 11.3
			PRO2(Pmodem, from, REPFUNCTIONINGSTATUS, osb());
		CONNECT =>	;
		DISCONNECT =>
			return ref Event.Eproto(Pscreen, from, Cscreenoff, "",0,0,0);
		RESET =>					# reset the minitel terminal
			all := Pscreen|Pmodem|Pkeyb|Psocket;
			post(ref Event.Eproto(all, from, Creset, "",0,0,0));	# check
			T.reset();
			reply := array [] of { byte SEP, byte 16r5E };
			post(ref Event.Edata(Pmodem, from, reply));
		}
	2 =>
		case p.arg[0] {
		TO =>					# request for module status
			PRO3(Pmodem, from, FROM, p.arg[1], psb(p.arg[1]));
		NOBROADCAST =>	;
		BROADCAST =>	;
		TRANSPARENCY =>			# transparency mode - skip bytes
			p.skip = p.arg[1];
			if(p.skip < 1 || p.skip > 127)	# 5.0
				p.skip = 0;
			else {
				reply := array [] of { byte SEP, byte 16r57 };
				post(ref Event.Edata(Pmodem, from, reply));
			}
		KEYBOARDSTATUS =>
			if(p.arg[1] == RxKeyb)
				PRO3(Pmodem, from, REPKEYBOARDSTATUS, RxKeyb, kosb());
		START =>
			x := osb();
			if(p.arg[1] == PROCEDURE)
				x |= 16r04;
			if(p.arg[1] == SCROLLING)
				x |= 16r02;
			PRO2(Pmodem, from, REPFUNCTIONINGSTATUS, x);
			case p.arg[1] {
			PROCEDURE =>			# activate error correction procedure
				sys->print("activate error correction\n");
				return ref Event.Eproto(Pmodem, from, Cstartecp, "",0,0,0);
			SCROLLING =>			# set screen to scroll
				return ref Event.Eproto(Pscreen, from, Cproto, "",START,SCROLLING,0);
			LOWERCASE =>			# set keyb to invert case
				return ref Event.Eproto(Pkeyb, from, Cproto, "",START,LOWERCASE,0);
			}
		STOP =>
			x := osb();	
			if(p.arg[1] == SCROLLING)
				x &= ~16r02;
			PRO2(Pmodem, from, REPFUNCTIONINGSTATUS, osb());
			case p.arg[1] {
			PROCEDURE =>			# deactivate error correction procedure
				sys->print("deactivate error correction\n");
				return ref Event.Eproto(Pmodem, from, Cstopecp, "",0,0,0);
			SCROLLING =>			# set screen to no scroll
				return ref Event.Eproto(Pscreen, from, Cproto, "",STOP,SCROLLING,0);
			LOWERCASE =>			# set keyb to not invert case
				return ref Event.Eproto(Pkeyb, from, Cproto, "",STOP,LOWERCASE,0);
			}
		COPY =>					# copy screen to socket
			# not implemented
			;
		MIXED =>					# change video mode (12.1)
			case p.arg[1] {
			MIXED1 =>			# videotex -> mixed
				reply := array [] of { byte SEP, byte 16r70 };
				return ref Event.Eproto(Pscreen, from, Cproto, "",MIXED,MIXED1,0);
			MIXED2 =>			# mixed -> videotex
				reply := array [] of { byte SEP, byte 16r71 };
				return ref Event.Eproto(Pscreen, from, Cproto, "",MIXED,MIXED2,0);
			}
		ASCII =>					# change video mode (12.2)
			# TODO
			;
		}
	3 =>
		case p.arg[0] {
		OFF or ON =>				# link, unlink, enable, disable
			modcmd(p.arg[0], p.arg[1], p.arg[2]);
			PRO3(Pmodem, from, FROM, p.arg[1], psb(TxCode(p.arg[1])));
		START =>	
			case p.arg[1] {
			RxKeyb =>			# keyboard mode
				case p.arg[2] {
				ETEN =>			# extended keyboard
					K.spec |= Extend;
				C0 =>			# cursor control key coding from col 0
					K.spec |= C0keys;
				}
				PRO3(Pmodem, from, REPKEYBOARDSTATUS, RxKeyb, kosb());
			}
		STOP =>					# keyboard mode
			case p.arg[1] {
			RxKeyb =>			# keyboard mode
				case p.arg[2] {
				ETEN =>			# extended keyboard
					K.spec &= ~Extend;
				C0 =>			# cursor control key coding from col 0
					K.spec &= ~C0keys;
				}
				PRO3(Pmodem, from, REPKEYBOARDSTATUS, RxKeyb, kosb());
			}
		}
	}
	return nil;
}

# post a PRO3 sequence to all modules on `path'
PRO3(path, from, x, y, z: int)
{
	data := array [] of { byte ESC, byte 16r3b, byte x, byte y, byte z};
	post(ref Event.Edata(path, from, data));
}

# post a PRO2 sequence to all modules on `path'
PRO2(path, from, x, y: int)
{
	data := array [] of { byte ESC, byte 16r3a, byte x, byte y};
	post(ref Event.Edata(path, from, data));
}

# post a PRO1 sequence to all modules on `path'
PRO1(path, from, x: int)
{
	data := array [] of { byte ESC, byte 16r39, byte x};
	post(ref Event.Edata(path, from, data));
}

# make or break links between modules, or enable and disable
modcmd(cmd, from, targ: int)
{
	from = RxTx(from);
	targ = RxTx(targ);
	if(from == targ)						# enable or disable module
		if(cmd == ON)
			Modules[from].disabled = 0;
		else
			Modules[from].disabled = 1;
	else 								# modify path
		if(cmd == ON)
			Modules[from].path |= (1<<targ);
		else
			Modules[from].path &= ~(1<<targ);
}

# determine the path status byte (3.4)
# if bit 3 of `code' is set then a receive path status byte is returned
# otherwise a transmit path status byte
psb(code: int): int
{
	this := RxTx(code);
	b := 16r40;			# bit 6 always set
	if(code == RxCode(code)) { 	# want a receive path status byte
		mask := (1<<this);
		if(Modules[Mscreen].path & mask)
			b |= 16r01;
		if(Modules[Mkeyb].path & mask)
			b |= 16r02;
		if(Modules[Mmodem].path & mask)
			b |= 16r04;
		if(Modules[Msocket].path & mask)
			b |= 16r08;
	} else {
		mod := Modules[this];
		if(mod.path & Mscreen)
			b |= 16r01;
		if(mod.path & Mkeyb)
			b |= 16r02;
		if(mod.path & Mmodem)
			b |= 16r04;
		if(mod.path & Msocket)
			b |= 16r08;
	}
#	if(parity(b))
#		b ^= 16r80;
	return b;
}

# convert `code' to a receive code by setting bit 3
RxCode(code: int): int
{
	return (code | 16r08)&16rff;
}

# covert `code' to a send code by clearing bit 3
TxCode(code: int): int
{
	return (code & ~16r08)&16rff;
}

# return 0 on even parity, 1 otherwise
# only the bottom 8 bits are considered
parity(b: int): int
{
	bits := 8;
	p := 0;
	while(bits-- > 0) {
		if(b&1)
			p ^= 1;
		b >>= 1;
	}
	return p;
}

# convert Rx or Tx code to a module code
RxTx(code: int): int
{
	rv := 0;
	case code {
	TxScreen or RxScreen	=> rv = Mscreen;
	TxKeyb or RxKeyb		=> rv = Mkeyb;
	TxModem or RxModem	=> rv = Mmodem;
	TxSocket or RxSocket	=> rv = Msocket;
	* =>
		fatal("invalid module code");
	}
	return rv;
}

# generate an operating status byte (11.2)
osb(): int
{
	b := 16r40;
	if(S.cols == 80)
		b |= 16r01;
	if(S.spec & Scroll)
		b |= 16r02;
	if(M.spec & Ecp)
		b |= 16r04;
	if(K.spec & Invert)
		b |= 16r08;
#	if(parity(b))
#		b ^= 16r80;
	return b;
}

# generate a keyboard operating status byte (9.1.2)
kosb(): int
{
	b := 16r40;
	if(K.spec & Extend)
		b |= 16r01;
	if(K.spec & C0keys)
		b |= 16r04;
#	if(parity(b))
#		b ^= 16r80;
	return b;
}

hex(v, n: int): string
{
	return sprint("%.*ux", n, v);
}

tostr(ch: int): string
{
	str := "";
	str[0] = ch;
	return str;
}

toint(s: string, base: int): (int, string)
{
	if(base < 0 || base > 36)
		return (0, s);

	c := 0;
	for(i := 0; i < len s; i++) {
		c = s[i];
		if(c != ' ' && c != '\t' && c != '\n')
			break;
	}

	neg := 0;
	if(c == '+' || c == '-') {
		if(c == '-')
			neg = 1;
		i++;
	}

	ok := 0;
	n := 0;
	for(; i < len s; i++) {
		c = s[i];
		v := base;
		case c {
		'a' to 'z' =>
			v = c - 'a' + 10;
		'A' to 'Z' =>
			v = c - 'A' + 10;
		'0' to '9' =>
			v = c - '0';
		}
		if(v >= base)
			break;
		ok = 1;
		n = n * base + v;
	}

	if(!ok)
		return (0, s);
	if(neg)
		n = -n;
	return (n, s[i:]);
}

tolower(s: string): string
{
	r := s;
	for(i := 0; i < len r; i++) {
		c := r[i];
		if(c >= int 'A' && c <= int 'Z')
			r[i] = r[i] + (int 'a' - int 'A');
	}
	return r;
}

# duplicate `ch' exactly `n' times
dup(ch, n: int): string
{
	str := "";
	for(i:=0; i<n; i++)
		str[i] = ch;
	return str;
}

fatal(msg: string)
{
	fprint(stderr, "fatal: %s\n", msg);
	exits(msg);
}

exits(s: string)
{
	if(s==nil);
#	raise "fail: miniterm " + s;
	fd := sys->open("#p/" + string pgrp + "/ctl", sys->OWRITE);
	if(fd != nil)
		sys->fprint(fd, "killgrp");
	exit;
}

# Minitel byte MSB and LSB classification (p.87)
MSB(ch: int): int
{
	return (ch&16r70)>>4;
}
LSB(ch: int): int
{
	return (ch&16r0f);
}

# Minitel character set classification (p.92)
ISC0(ch: int): int
{
	msb := (ch&16r70)>>4;
	return msb == 0 || msb == 1;
}

ISC1(ch: int): int
{
	return ch >= 16r40 && ch <= 16r5f;
}

ISG0(ch: int): int
{
	# 0x20 (space) and 0x7f (DEL) are not in G0
	return ch > 16r20 && ch < 16r7f;
}

tkcmds(t: ref Tk->Toplevel, cmds: array of string)
{
	n := len cmds;
	for (ix := 0; ix < n; ix++)
		tk->cmd(t, cmds[ix]);
}