20060303-partial

1 files changed, 246 insertions, 0 deletions

diff --git a/module/alphabet.m b/module/alphabet.m
new file mode 100644
index 00000000..8158201c
--- /dev/null
+++ b/module/alphabet.m
@@ -0,0 +1,246 @@
+Alphabet: module {
+	PATH: con "/dis/alphabet/alphabet.dis";
+	ONDEMAND, CHECK: con 1<<iota;
+
+	init:	fn();
+	copy: fn(): Alphabet;
+	quit: fn();
+	loadtypeset: fn(qname: string, c: chan of ref Proxy->Typescmd[ref Value], errorc: chan of string): string;
+	declare: fn(qname: string, sig: string, flags: int): string;
+	undeclare: fn(name: string): string;
+	importmodule: fn(qname: string): string;
+	importtype: fn(qname: string): string;
+	importvalue: fn(v: ref Value, qname: string): (ref Value, string);
+	autoconvert: fn(src, dst: string, transform: ref Sh->Cmd, errorc: chan of string): string;
+	define: fn(name: string, expr: ref Sh->Cmd, errorc: chan of string): string;
+	setautodeclare: fn(on: int);
+
+	Decltypeset: adt {
+		name: string;
+		alphabet: string;
+		types: array of string;
+		mods: array of (string, string);
+	};
+	Declarations: adt {
+		typesets: array of Decltypeset;
+		defs: array of (string, string);
+	};
+#	getdecls: fn(): ref Declarations;
+#	getexprdecls: fn(e: ref Sh->Cmd): ref Declarations;
+#	declcompat: fn(d0, d1: ref Declarations): int;
+
+	getmodule: fn(name: string): (string, string, ref Sh->Cmd);
+	gettypesets: fn(): list of string;
+	getmodules: fn(): list of string;
+	gettypesetmodules: fn(tsname: string): chan of string;
+	gettypes: fn(typeset: string): list of string;
+	getautoconversions: fn(): list of (string, string, ref Sh->Cmd);
+	typecompat: fn(t0, t1: string): (int, string);
+	show: fn();
+
+	mkqname: fn(typeset, name: string): string;
+	canon: fn(qname: string): string;
+	splitqname: fn(qname: string): (string, string);
+	parse: fn(expr: string): (ref Sh->Cmd, string);
+
+	eval: fn(expr: ref Sh->Cmd,
+			drawctxt: ref Draw->Context,
+			args: list of ref Value): string;
+	eval0: fn(expr: ref Sh->Cmd,
+			dsttype: string,
+			drawctxt: ref Draw->Context,
+			report: ref Reports->Report,
+			errorc: chan of string,
+			args: list of ref Value,
+			vc: chan of ref Value);
+	rewrite: fn(expr: ref Sh->Cmd, dsttype: string,
+			errorc: chan of string): (ref Sh->Cmd, string);
+	
+	Value: adt {
+		free:		fn(v: self ref Value, used: int);
+		dup:		fn(v: self ref Value): ref Value;
+		gets:		fn(v: self ref Value): string;
+		isstring:	fn(v: self ref Value): int;
+		type2s:	fn(tc: int): string;
+		typec:	fn(v: self ref Value): int;
+		typename: fn(v: self ref Value): string;
+
+		c: fn(v: self ref Value): ref Value.Vc;
+		s: fn(v: self ref Value): ref Value.Vs;
+		r: fn(v: self ref Value): ref Value.Vr;
+		f: fn(v: self ref Value): ref Value.Vf;
+		w: fn(v: self ref Value): ref Value.Vw;
+		d: fn(v: self ref Value): ref Value.Vd;
+		z: fn(v: self ref Value): ref Value.Vz;
+
+		pick{
+		Vc =>
+			i: ref Sh->Cmd;
+		Vs =>
+			i: string;
+		Vr =>
+			i: chan of string;
+		Vf or
+		Vw =>
+			i: chan of ref Sys->FD;
+		Vd =>
+			i: Datachan;
+		Vz =>
+			i: Proxyval;		# a proxy for the actual value, held by another process
+		}
+	};
+
+	Proxyval: adt {
+		typec: int;
+		id: int;
+	};
+
+	Datachan: adt {
+		d: chan of array of byte;
+		stop: chan of int;
+	};
+};
+
+Mainmodule: module {
+	typesig: fn(): string;
+	init:	fn();
+	quit: fn();
+	run: fn(ctxt: ref Draw->Context, r: ref Reports->Report, errorc: chan of string,
+		opts: list of (int, list of ref Alphabet->Value), args: list of ref Alphabet->Value): ref Alphabet->Value;
+};
+
+# evaluate an expression
+Eval: module {
+	PATH: con "/dis/alphabet/eval.dis";
+	init: fn();
+
+	Context: adt[V, M, Ectxt]
+		for {
+		V =>
+			dup:		fn(t: self V): V;
+			free:		fn(v: self V, used: int);
+			isstring:	fn(v: self V): int;
+			gets:		fn(t: self V): string;
+			type2s:	fn(tc: int): string;
+			typec:	fn(t: self V): int;
+		M =>
+			find:		fn(c: Ectxt, s: string): (M, string);
+			typesig:	fn(m: self M): string;
+			run:		fn(m: self M, c: Ectxt, errorc: chan of string,
+						opts: list of (int, list of V), args: list of V): V;
+			mks:		fn(c: Ectxt, s: string): V;
+			mkc:		fn(c: Ectxt, cmd: ref Sh->Cmd): V;
+			typename2c: fn(s: string): int;
+			cvt:		fn(c: Ectxt, v: V, tc: int, errorc: chan of string): V;
+		}
+	{
+		eval: fn(
+			expr: ref Sh->Cmd,
+			ctxt: Ectxt,
+			errorc: chan of string,
+			args: list of V
+		): V;
+	};
+	cmdusage: fn[V](nil: V, sig: string): string
+		for {
+		V =>
+			type2s:	fn(tc: int): string;
+		};
+	usage2sig: fn[V](nil: V, u: string): (string, string)
+		for{
+		V =>
+			typename2c: fn(s: string): int;
+		};
+	blocksig: fn[M, Ectxt](nil: M, ctxt: Ectxt, c: ref Sh->Cmd): (string, string)
+		for{
+		M =>
+			typename2c: fn(s: string): int;
+			find:	fn(c: Ectxt, s: string): (M, string);
+			typesig: fn(m: self M): string;
+		};
+	typecompat: fn(t0, t1: string): int;
+	splittype: fn(t: string): (int, string, string);
+};
+
+Extvalues: module {
+	PATH: con "/dis/alphabet/extvalues.dis";
+	Values: adt[V] {
+		lock: chan of int;
+		v: array of (int, V);
+		freeids: list of int;
+		new: fn(): ref Values[V];
+		add: fn(vals: self ref Values, v: V): int;
+		inc: fn(vals: self ref Values, id: int);
+		del: fn(vals: self ref Values, id: int);
+	};
+};
+
+# generic proxy implementation:
+Proxy: module {
+	PATH: con "/dis/alphabet/proxy.dis";
+
+	# operators on a type system
+	Typescmd: adt[V] {
+		pick {
+		Load =>
+			cmd: string;
+			reply: chan of (chan of ref Modulecmd[V], string);
+		Dup =>
+			v: V;
+			reply: chan of V;
+		Free =>
+			v: V;
+			used: int;
+			reply: chan of int;
+		Alphabet =>
+			reply: chan of string;
+		Type2s =>
+			tc: int;
+			reply: chan of string;
+		Loadtypes =>
+			name: string;
+			reply: chan of (chan of ref Typescmd[V], string);
+		Modules =>
+			reply: chan of string;
+		}
+	};
+	
+	# proxy for a loaded module.
+	Modulecmd: adt[V] {
+		pick {
+		Typesig =>
+			reply: chan of string;
+		Run =>
+			ctxt: ref Draw->Context;
+			report: ref Reports->Report;
+			errorc: chan of string;
+#			stopc: chan of int;
+			opts: list of (int, list of V);
+			args: list of V;
+			reply: chan of V;
+		}
+	};
+
+	proxy: fn[Ctxt,Cvt,M,V,EV](ctxt: Ctxt): (
+			chan of ref Proxy->Typescmd[EV],
+			chan of (string, chan of ref Proxy->Typescmd[V])
+		) for {
+		M =>
+			typesig: fn(m: self M): string;
+			run: fn(m: self M, ctxt: ref Draw->Context, r: ref Reports->Report, errorc: chan of string,
+					opts: list of (int, list of V), args: list of V): V;
+			quit: fn(m: self M);
+		Ctxt =>
+			loadtypes: fn(ctxt: self Ctxt, name: string): (chan of ref Proxy->Typescmd[V], string);
+			type2s: fn(ctxt: self Ctxt, tc: int): string;
+			alphabet: fn(ctxt: self Ctxt): string;
+			modules: fn(ctxt: self Ctxt, r: chan of string);
+			find: fn(ctxt: self Ctxt, s: string): (M, string);
+			getcvt: fn(ctxt: self Ctxt): Cvt;
+		Cvt =>
+			int2ext: fn(cvt: self Cvt, v: V): EV;
+			ext2int: fn(cvt: self Cvt, ev: EV): V;
+			free: fn(cvt: self Cvt, v: EV, used: int);
+			dup:	fn(cvt: self Cvt, v: EV): EV;
+	};
+};