code: purgatorio

Info  •  Files  •  Log

add missing files ;; add pete whois/tac

--- /dev/null

+++ b/appl/cmd/disdep.b

@@ -1,0 +1,250 @@

+implement Disdep;

+

+#

+# Copyright  © 2000 Vita Nuova Limited.  All rights reserved.

+#

+

+include "sys.m";

+	sys: Sys;

+	print, sprint: import sys;

+

+include "bufio.m";

+	bufio: Bufio;

+	Iobuf: import bufio;

+

+include "draw.m";

+

+include "string.m";

+	str: String;

+

+include "arg.m";

+	arg: Arg;

+

+include "dis.m";

+	dis: Dis;

+	Mod: import dis;

+

+include "hash.m";

+	hash: Hash;

+	HashTable, HashVal: import hash;

+

+Disdep: module

+{

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

+};

+

+Item: adt {

+	name:	string;

+	needs:	cyclic list of ref Item;

+	visited:	int;

+

+	find:		fn(s: string): ref Item;

+};

+

+bout: ref Iobuf;

+pending: list of ref Item;

+roots: list of ref Item;

+tab: ref HashTable;

+aflag := 0;		# display all non-recursive dependencies

+oflag := 0;		# only list the immediate (outer) dependencies

+sflag := 0;		# include $system modules

+pflag := 0;		# show dependency sets as pairs, one per line

+showdepth := 0;	# indent to show the dependency structure

+

+noload(mod: string)

+{

+	sys->fprint(sys->fildes(2), "disdep: can't load %s: %r\n", mod);

+	raise "fail:load";

+}

+

+usage()

+{

+	sys->fprint(sys->fildes(2), "Usage: disdep [-a] [-d] [-o] [-p] [-s] file.dis ...\n");

+	raise "fail:usage";

+}

+

+init(nil: ref Draw->Context, argv: list of string)

+{

+	sys = load Sys Sys->PATH;

+	bufio = load Bufio Bufio->PATH;

+	if(bufio == nil)

+		noload(Bufio->PATH);

+

+	str = load String String->PATH;

+	if(str == nil)

+		noload(String->PATH);

+

+	hash = load Hash Hash->PATH;

+	if(hash == nil)

+		noload(Hash->PATH);

+

+	arg = load Arg Arg->PATH;

+	if(arg == nil)

+		noload(Arg->PATH);

+

+	dis = load Dis Dis->PATH;

+	if(dis == nil)

+		noload(Dis->PATH);

+	dis->init();

+

+	arg->init(argv);

+	while((opt := arg->opt()) != 0)

+		case opt {

+		'a' => aflag = 1; showdepth = 1;

+		'o' => oflag = 1;

+		's' => sflag = 1;

+		'd' => showdepth = 1;

+		'p' => pflag = 1;

+		* => usage();

+		}

+

+	argv = arg->argv();

+	if(argv == nil)

+		usage();

+

+	tab = hash->new(521);

+

+	bout = bufio->fopen(sys->fildes(1), Sys->OWRITE);

+	for(l := rev(argv); l != nil; l = tl l)

+		roots = Item.find(hd l) :: roots;

+	pending = roots;

+	while(pending != nil){

+		f := hd pending;

+		pending = tl pending;

+		(m, s) := dis->loadobj(f.name);

+		if(s != nil){

+			sys->fprint(sys->fildes(2), "disdep: can't open %s: %s\n", f.name, s);

+			continue;

+		}

+		f.needs = disfind(m);

+		for(nl := f.needs; nl != nil; nl = tl nl){

+			n := hd nl;

+			if(!n.visited){

+				n.visited = 1;

+				if(!oflag && !isdol(n.name))

+					pending = n :: pending;

+			}

+		}

+	}

+

+	if(pflag){

+		for(i := 0; i < nextitem; i++){

+			f := items[i];

+			if(f.needs != nil){

+				for(nl := f.needs; nl != nil; nl = tl nl){

+					bout.puts(f.name);

+					bout.putc(' ');

+					bout.puts((hd nl).name);

+					bout.putc('\n');

+				}

+			}else{

+				bout.puts(f.name);

+				bout.putc('\n');

+			}

+		}

+	}else{

+		unvisited();

+		for(; roots != nil; roots = tl roots){

+			if(aflag)

+				unvisited();

+			f := hd roots;

+			depth := 0;

+			if(showdepth){

+				bout.puts(f.name);

+				bout.putc('\n');

+				depth = 1;

+			}

+			prdep(hd roots, depth);

+		}

+	}

+	bout.flush();

+}

+

+disfind(m: ref Mod): list of ref Item

+{

+	needs: list of ref Item;

+	for(d := m.data; d != nil; d = tl d) {

+		pick dat := hd d {

+		String =>

+			if(isdisfile(dat.str) || sflag && isdol(dat.str))

+				needs = Item.find(dat.str) :: needs;

+		}

+	}

+	return rev(needs);

+}

+

+prdep(f: ref Item, depth: int)

+{

+	f.visited = 1;	# short-circuit self-reference

+	for(nl := f.needs; nl != nil; nl = tl nl){

+		n := hd nl;

+		if(!n.visited){

+			n.visited = 1;

+			name(n.name, depth);

+			prdep(n, depth+1);

+		}else if(aflag)

+			name(n.name, depth);

+	}

+}

+			

+items := array[100] of ref Item;

+nextitem := 0;

+

+Item.find(name: string): ref Item

+{

+	k := tab.find(name);

+	if(k != nil)

+		return items[k.i];

+	if(nextitem >= len items){

+		a := array[len items + 100] of ref Item;

+		a[0:] = items;

+		items = a;

+	}

+	f := ref Item;

+	f.name = name;

+	f.visited = 0;

+	items[nextitem] = f;

+	tab.insert(name, HashVal(nextitem, 0.0, nil));

+	nextitem++;

+	return f;

+}

+

+unvisited()

+{

+	for(i := 0; i < nextitem; i++)

+		items[i].visited = 0;

+}

+

+name(s: string, depth: int)

+{

+	if(showdepth)

+		for(i:=0; i<depth; i++)

+			bout.putc('\t');

+	bout.puts(s);

+	bout.putc('\n');

+}

+

+isdisfile(s: string): int

+{

+	if(len s > 4 && s[len s-4:]==".dis"){	# worth a look

+		for(i := 0; i < len s; i++)

+			if(s[i] <= ' ' || s[i] == '%')

+				return 0;

+		return 1;

+	}

+	return 0;

+}

+

+isdol(s: string): int

+{

+	return len s > 1 && s[0] == '$' && s[1]>='A' && s[1]<='Z';	# reasonable guess

+}

+

+rev[T](l: list of T): list of T

+{

+	t: list of T;

+	for(; l != nil; l = tl l)

+		t = hd l :: t;

+	return t;

+}

+

--- /dev/null

+++ b/appl/cmd/disdump.b

@@ -1,0 +1,52 @@

+implement Disdump;

+

+include "sys.m";

+	sys: Sys;

+include "draw.m";

+include "dis.m";

+	dis: Dis;

+include "bufio.m";

+	bufio: Bufio;

+	Iobuf: import bufio;

+

+Disdump: module {

+	init: fn(nil: ref Draw->Context, argv: list of string);

+};

+

+init(nil: ref Draw->Context, argv: list of string)

+{

+	sys = load Sys Sys->PATH;

+	stderr := sys->fildes(2);

+	bufio = load Bufio Bufio->PATH;

+	if (bufio == nil) {

+		sys->fprint(stderr, "dis: cannot load %s: %r\n", Bufio->PATH);

+		raise "fail:bad module";

+	}

+

+	dis = load Dis Dis->PATH;

+	if (dis == nil) {

+		sys->fprint(stderr, "dis: cannot load %s: %r\n", Dis->PATH);

+		raise "fail:bad module";

+	}

+

+	if (len argv < 2) {

+		sys->fprint(stderr, "usage: dis module...\n");

+		raise "fail:usage";

+	}

+	dis->init();

+	out := bufio->fopen(sys->fildes(1), Sys->OWRITE);

+	errs := 0;

+	for (argv = tl argv; argv != nil; argv = tl argv) {

+		(mod, err) := dis->loadobj(hd argv);

+		if (mod == nil) {

+			sys->fprint(stderr, "dis: failed to load %s: %s\n", hd argv, err);

+			errs++;

+			continue;

+		}

+		for (i := 0; i < len mod.inst; i++)

+			out.puts(dis->inst2s(mod.inst[i])+"\n");

+	}

+	out.close();

+	if (errs)

+		raise "fail:errors";

+}

--- /dev/null

+++ b/appl/cmd/limbo/dis.b

@@ -1,0 +1,560 @@

+

+NAMELEN:	con 28;

+

+cache:		array of byte;

+ncached:	int;

+ndatum:		int;

+startoff:	int;

+lastoff:	int;

+lastkind:	int;

+

+discon(val: int)

+{

+	if(val >= -64 && val <= 63){

+		bout.putb(byte (val & ~16r80));

+		return;

+	}

+	if(val >= -8192 && val <= 8191){

+		bout.putb(byte ((val>>8) & ~16rC0 | 16r80));

+		bout.putb(byte val);

+		return;

+	}

+	if(val < 0 && ((val >> 29) & 7) != 7

+	|| val > 0 && (val >> 29) != 0)

+		fatal("overflow in constant 16r"+hex(val, 0));

+	bout.putb(byte(val>>24 | 16rC0));

+	bout.putb(byte(val>>16));

+	bout.putb(byte(val>>8));

+	bout.putb(byte val);

+}

+

+disword(w: int)

+{

+	bout.putb(byte(w >> 24));

+	bout.putb(byte(w >> 16));

+	bout.putb(byte(w >> 8));

+	bout.putb(byte w);

+}

+

+disdata(kind, n: int)

+{

+	if(n < DMAX && n != 0)

+		bout.putb(byte((kind << DBYTE) | n));

+	else{

+		bout.putb(byte kind << DBYTE);

+		discon(n);

+	}

+}

+

+dismod(m: ref Decl)

+{

+	fileoff := bout.seek(big 0, 1);

+	name := array of byte m.sym.name;

+	n := len name;

+	if(n > NAMELEN-1)

+		n = NAMELEN-1;

+	bout.write(name, n);

+	bout.putb(byte 0);

+	for(m = m.ty.tof.ids; m != nil; m = m.next){

+		case m.store{

+		Dglobal =>

+			discon(-1);

+			discon(-1);

+			disword(sign(m));

+			bout.puts(".mp");

+			bout.putb(byte 0);

+		Dfn =>

+			discon(m.pc.pc);

+			discon(m.desc.id);

+			disword(sign(m));

+			if(m.dot.ty.kind == Tadt){

+				bout.puts(m.dot.sym.name);

+				bout.putb(byte '.');

+			}

+			bout.puts(m.sym.name);

+			bout.putb(byte 0);

+		* =>

+			fatal("unknown kind in dismod: "+declconv(m));

+		}

+	}

+	if(debug['s'])

+		print("%bd linkage bytes start %bd\n", bout.seek(big 0, 1) - fileoff, fileoff);

+}

+

+dispath()

+{

+	sp := array of byte srcpath();

+	bout.write(sp, len sp);

+	bout.putb(byte 0);

+}

+

+disentry(e: ref Decl)

+{

+	if(e == nil){

+		discon(-1);

+		discon(-1);

+		return;

+	}

+	discon(e.pc.pc);

+	discon(e.desc.id);

+}

+

+disdesc(d: ref Desc)

+{

+	fileoff := bout.seek(big 0, 1);

+	for(; d != nil; d = d.next){

+		discon(d.id);

+		discon(d.size);

+		discon(d.nmap);

+		bout.write(d.map, d.nmap);

+	}

+	if(debug['s'])

+		print("%bd type descriptor bytes start %bd\n", bout.seek(big 0, 1) - fileoff, fileoff);

+}

+

+disvar(nil: int, ids: ref Decl)

+{

+	fileoff := bout.seek(big 0, 1);

+	lastkind = -1;

+	ncached = 0;

+	ndatum = 0;

+

+	for(d := ids; d != nil; d = d.next)

+		if(d.store == Dglobal && d.init != nil)

+			disdatum(d.offset, d.init);

+

+	disflush(-1, -1, 0);

+

+	bout.putb(byte 0);

+

+	if(debug['s'])

+		print("%bd data bytes start %bd\n", bout.seek(big 0, 1) - fileoff, fileoff);

+}

+

+disldt(size: int, ds: ref Decl)

+{

+	if(0){

+		discon(size);

+		disvar(size, ds);

+		return;

+	}

+

+	m := 0;

+	for(d := ds; d != nil; d = d.next)

+		if(d.store == Dglobal && d.init != nil)

+			m++;

+	discon(m);

+	n: ref Node;

+	for(d = ds; d != nil; d = d.next){

+		if(d.store == Dglobal && d.init != nil){

+			n = d.init;

+			if(n.ty.kind != Tiface)

+				nerror(n, "disldt: not Tiface");

+			discon(int n.c.val);

+			for(id := n.decl.ty.ids; id != nil; id = id.next){

+				disword(sign(id));

+				if(id.dot.ty.kind == Tadt){

+					s := array of byte id.dot.sym.name;

+					bout.write(s, len s);

+					bout.putb(byte '.');

+				}

+				s := array of byte id.sym.name;

+				bout.write(s, len s);

+				bout.putb(byte 0);

+			}

+		}

+	}

+	discon(0);

+}

+

+disdatum(offset: int, n: ref Node)

+{

+	c: ref Case;

+	lab: Label;

+	id: ref Decl;

+	wild: ref Node;

+	i, e: int;

+

+	case n.ty.kind{

+	Tbyte =>

+		disbyte(offset, byte n.c.val);

+	Tint or

+	Tfix =>

+		disint(offset, int n.c.val);

+	Tbig =>

+		disbig(offset, n.c.val);

+	Tstring =>

+		disstring(offset, n.decl.sym);

+	Treal =>

+		disreal(offset, n.c.rval);

+	Tadt or

+	Tadtpick or

+	Ttuple =>

+		id = n.ty.ids;

+		for(n = n.left; n != nil; n = n.right){

+			disdatum(offset + id.offset, n.left);

+			id = id.next;

+		}

+	Tany =>

+		break;

+	Tcase =>

+		c = n.ty.cse;

+		disint(offset, c.nlab);

+		offset += IBY2WD;

+		for(i = 0; i < c.nlab; i++){

+			lab = c.labs[i];

+			disint(offset, int lab.start.c.val);

+			offset += IBY2WD;

+			disint(offset, int lab.stop.c.val+1);

+			offset += IBY2WD;

+			disint(offset, lab.inst.pc);

+			offset += IBY2WD;

+		}

+		if(c.iwild != nil)

+			disint(offset, c.iwild.pc);

+		else

+			disint(offset, -1);

+	Tcasel =>

+		c = n.ty.cse;

+		disint(offset, c.nlab);

+		offset += 2*IBY2WD;

+		for(i = 0; i < c.nlab; i++){

+			lab = c.labs[i];

+			disbig(offset, lab.start.c.val);

+			offset += IBY2LG;

+			disbig(offset, lab.stop.c.val+big 1);

+			offset += IBY2LG;

+			disint(offset, lab.inst.pc);

+			offset += 2*IBY2WD;

+		}

+		if(c.iwild != nil)

+			disint(offset, c.iwild.pc);

+		else

+			disint(offset, -1);

+	Tcasec =>

+		c = n.ty.cse;

+		disint(offset, c.nlab);

+		offset += IBY2WD;

+		for(i = 0; i < c.nlab; i++){

+			lab = c.labs[i];

+			disstring(offset, lab.start.decl.sym);

+			offset += IBY2WD;

+			if(lab.stop != lab.start)

+				disstring(offset, lab.stop.decl.sym);

+			offset += IBY2WD;

+			disint(offset, lab.inst.pc);

+			offset += IBY2WD;

+		}

+		if(c.iwild != nil)

+			disint(offset, c.iwild.pc);

+		else

+			disint(offset, -1);

+	Tgoto =>

+		c = n.ty.cse;

+		disint(offset, n.ty.size/IBY2WD-1);

+		offset += IBY2WD;

+		for(i = 0; i < c.nlab; i++){

+			disint(offset, c.labs[i].inst.pc);

+			offset += IBY2WD;

+		}

+		if(c.iwild != nil)

+			disint(offset, c.iwild.pc);

+	Tarray =>

+		disflush(-1, -1, 0);

+		disdata(DEFA, 1);		# 1 is ignored

+		discon(offset);

+		disword(n.ty.tof.decl.desc.id);

+		disword(int n.left.c.val);

+

+		if(n.right == nil)

+			break;

+

+		disdata(DIND, 1);		# 1 is ignored

+		discon(offset);

+		disword(0);

+

+		c = n.right.ty.cse;

+		wild = nil;

+		if(c.wild != nil)

+			wild = c.wild.right;

+		last := 0;

+		esz := n.ty.tof.size;

+		for(i = 0; i < c.nlab; i++){

+			e = int c.labs[i].start.c.val;

+			if(wild != nil){

+				for(; last < e; last++)

+					disdatum(esz * last, wild);

+			}

+			last = e;

+			e = int c.labs[i].stop.c.val;

+			elem := c.labs[i].node.right;

+			for(; last <= e; last++)

+				disdatum(esz * last, elem);

+		}

+		if(wild != nil)

+			for(e = int n.left.c.val; last < e; last++)

+				disdatum(esz * last, wild);

+

+		disflush(-1, -1, 0);

+		disdata(DAPOP, 1);		# 1 is ignored

+		discon(0);

+	Tiface =>

+		disint(offset, int n.c.val);

+		offset += IBY2WD;

+		for(id = n.decl.ty.ids; id != nil; id = id.next){

+			offset = align(offset, IBY2WD);

+			disint(offset, sign(id));

+			offset += IBY2WD;

+

+			name: array of byte;

+			if(id.dot.ty.kind == Tadt){

+				name = array of byte id.dot.sym.name;

+				disbytes(offset, name);

+				offset += len name;

+				disbyte(offset, byte '.');

+				offset++;

+			}

+			name = array of byte id.sym.name;

+			disbytes(offset, name);

+			offset += len name;

+			disbyte(offset, byte 0);

+			offset++;

+		}

+	* =>

+		fatal("can't gen global "+nodeconv(n));

+	}

+}

+

+disexc(es: ref Except)

+{

+	e: ref Except;

+

+	n := 0;

+	for(e = es; e != nil; e = e.next)

+		if(int e.p1.reach || int e.p2.reach)

+			n++;

+	discon(n);

+	for(e = es; e != nil; e = e.next){

+		if(!int e.p1.reach && !int e.p2.reach)

+			continue;

+		c := e.c;

+		discon(e.d.offset);

+		discon(getpc(e.p1));

+		discon(getpc(e.p2));

+		if(e.desc != nil)

+			discon(e.desc.id);

+		else

+			discon(-1);

+		discon(c.nlab|(e.ne<<16));

+		for(i := 0; i < c.nlab; i++){

+			lab := c.labs[i];

+			d := lab.start.decl;

+			if(lab.start.ty.kind == Texception)

+				d = d.init.decl;

+			bout.puts(d.sym.name);

+			bout.putb(byte 0);

+			discon(lab.inst.pc);

+		}

+		if(c.iwild == nil)

+			discon(-1);

+		else

+			discon(c.iwild.pc);

+	}

+	discon(0);

+}

+

+disbyte(off: int, v: byte)

+{

+	disflush(DEFB, off, 1);

+	cache[ncached++] = v;

+	ndatum++;

+}

+

+disbytes(off: int, v: array of byte)

+{

+	n := len v;

+	disflush(DEFB, off, n);

+	cache[ncached:] = v;

+	ncached += n;

+	ndatum += n;

+}

+

+disint(off, v: int)

+{

+	disflush(DEFW, off, IBY2WD);

+	cache[ncached++] = byte(v >> 24);

+	cache[ncached++] = byte(v >> 16);

+	cache[ncached++] = byte(v >> 8);

+	cache[ncached++] = byte(v);

+	ndatum++;

+}

+

+disbig(off: int, v: big)

+{

+	disflush(DEFL, off, IBY2LG);

+	iv := int(v >> 32);

+	cache[ncached++] = byte(iv >> 24);

+	cache[ncached++] = byte(iv >> 16);

+	cache[ncached++] = byte(iv >> 8);

+	cache[ncached++] = byte(iv);

+	iv = int v;

+	cache[ncached++] = byte(iv >> 24);

+	cache[ncached++] = byte(iv >> 16);

+	cache[ncached++] = byte(iv >> 8);

+	cache[ncached++] = byte(iv);

+	ndatum++;

+}

+

+disreal(off: int, v: real)

+{

+	disflush(DEFF, off, IBY2LG);

+	export_real(cache[ncached:ncached+8], array[] of {v});

+	ncached += IBY2LG;

+	ndatum++;

+}

+

+disstring(offset: int, sym: ref Sym)

+{

+	disflush(-1, -1, 0);

+	d := array of byte sym.name;

+	disdata(DEFS, len d);

+	discon(offset);

+	bout.write(d, len d);

+}

+

+disflush(kind, off, size: int)

+{

+	if(kind != lastkind || off != lastoff){

+		if(lastkind != -1 && ncached){

+			disdata(lastkind, ndatum);

+			discon(startoff);

+			bout.write(cache, ncached);

+		}

+		startoff = off;

+		lastkind = kind;

+		ncached = 0;

+		ndatum = 0;

+	}

+	lastoff = off + size;

+	while(kind >= 0 && ncached + size >= len cache){

+		c := array[ncached + 1024] of byte;

+		c[0:] = cache;

+		cache = c;

+	}

+}

+

+dismode := array[int Aend] of

+{

+	int Aimm =>	byte AIMM,

+	int Amp =>	byte AMP,

+	int Ampind =>	byte(AMP|AIND),

+	int Afp =>	byte AFP,

+	int Afpind =>	byte(AFP|AIND),

+	int Apc =>	byte AIMM,

+	int Adesc =>	byte AIMM,

+	int Aoff =>	byte AIMM,

+	int Anoff =>	byte AIMM,

+	int Aerr =>	byte AXXX,

+	int Anone =>	byte AXXX,

+	int Aldt =>	byte AIMM,

+};

+

+disregmode := array[int Aend] of

+{

+	int Aimm =>	byte AXIMM,

+	int Amp =>	byte AXINM,

+	int Ampind =>	byte AXNON,

+	int Afp =>	byte AXINF,

+	int Afpind =>	byte AXNON,

+	int Apc =>	byte AXIMM,

+	int Adesc =>	byte AXIMM,

+	int Aoff =>	byte AXIMM,

+	int Anoff =>	byte AXIMM,

+	int Aerr =>	byte AXNON,

+	int Anone =>	byte AXNON,

+	int Aldt =>	byte AXIMM,

+};

+

+MAXCON: con 4;

+MAXADDR: con 2*MAXCON;

+MAXINST: con 3*MAXADDR+2;

+NIBUF: con 1024;

+

+ibuf:	array of byte;

+nibuf:	int;

+

+disinst(in: ref Inst)

+{

+	fileoff := bout.seek(big 0, 1);

+	ibuf = array[NIBUF] of byte;

+	nibuf = 0;

+	for(; in != nil; in = in.next){

+		if(in.op == INOOP)

+			continue;

+		if(nibuf >= NIBUF-MAXINST){

+			bout.write(ibuf, nibuf);

+			nibuf = 0;

+		}

+		ibuf[nibuf++] = byte in.op;

+		o := dismode[int in.sm] << SRC;

+		o |= dismode[int in.dm] << DST;

+		o |= disregmode[int in.mm];

+		ibuf[nibuf++] = o;

+		if(in.mm != Anone)

+			disaddr(in.mm, in.m);

+		if(in.sm != Anone)

+			disaddr(in.sm, in.s);

+		if(in.dm != Anone)

+			disaddr(in.dm, in.d);

+	}

+	if(nibuf > 0)

+		bout.write(ibuf, nibuf);

+	ibuf = nil;

+

+	if(debug['s'])

+		print("%bd instruction bytes start %bd\n", bout.seek(big 0, 1) - fileoff, fileoff);

+}

+

+disaddr(m: byte, a: Addr)

+{

+	val := 0;

+	case int m{

+	int Aimm or

+	int Apc or

+	int Adesc =>

+		val = a.offset;

+	int Aoff =>

+		val = a.decl.iface.offset;

+	int Anoff =>

+		val = -(a.decl.iface.offset+1);

+	int Afp or

+	int Amp or

+	int Aldt =>

+		val = a.reg;

+	int Afpind or

+	int Ampind =>

+		disbcon(a.reg);

+		val = a.offset;

+	}

+	disbcon(val);

+}

+

+disbcon(val: int)

+{

+	if(val >= -64 && val <= 63){

+		ibuf[nibuf++] = byte(val & ~16r80);

+		return;

+	}

+	if(val >= -8192 && val <= 8191){

+		ibuf[nibuf++] = byte(val>>8 & ~16rC0 | 16r80);

+		ibuf[nibuf++] = byte val;

+		return;

+	}

+	if(val < 0 && ((val >> 29) & 7) != 7

+	|| val > 0 && (val >> 29) != 0)

+		fatal("overflow in constant 16r"+hex(val, 0));

+	ibuf[nibuf++] = byte(val>>24 | 16rC0);

+	ibuf[nibuf++] = byte(val>>16);

+	ibuf[nibuf++] = byte(val>>8);

+	ibuf[nibuf++] = byte val;

+}

--- /dev/null

+++ b/appl/cmd/limbo/disoptab.m

@@ -1,0 +1,355 @@

+movetab:= array [Mend]of

+{

+	Mas => array[Tend] of

+	{

+		Tadt =>		IMOVM,

+		Tadtpick =>	IMOVM,

+		Tarray =>	IMOVP,

+		Tbig =>		IMOVL,

+		Tbyte =>	IMOVB,

+		Tchan =>	IMOVP,

+		Treal =>	IMOVF,

+		Tint =>		IMOVW,

+		Tlist =>	IMOVP,

+		Tmodule =>	IMOVP,

+		Tref =>		IMOVP,

+		Tstring =>	IMOVP,

+		Ttuple =>	IMOVM,

+		Texception => IMOVM,

+		Tfix =>	IMOVW,

+		Tpoly =>	IMOVP,

+

+		Tany =>		IMOVP,

+

+		* =>		0

+	},

+	Mcons => array[Tend] of

+	{

+		Tadt =>		ICONSM,

+		Tadtpick =>	0,

+		Tarray =>	ICONSP,

+		Tbig =>		ICONSL,

+		Tbyte =>	ICONSB,

+		Tchan =>	ICONSP,

+		Treal =>	ICONSF,

+		Tint =>		ICONSW,

+		Tlist =>	ICONSP,

+		Tmodule =>	ICONSP,

+		Tref =>		ICONSP,

+		Tstring =>	ICONSP,

+		Ttuple =>	ICONSM,

+		Texception => ICONSM,

+		Tfix =>	ICONSW,

+		Tpoly =>	ICONSP,

+

+		Tany =>		ICONSP,

+

+		* =>		0

+	},

+	Mhd => array[Tend] of

+	{

+		Tadt =>		IHEADM,

+		Tadtpick =>	0,

+		Tarray =>	IHEADP,

+		Tbig =>		IHEADL,

+		Tbyte =>	IHEADB,

+		Tchan =>	IHEADP,

+		Treal =>	IHEADF,

+		Tint =>		IHEADW,

+		Tlist =>	IHEADP,

+		Tmodule =>	IHEADP,

+		Tref =>		IHEADP,

+		Tstring =>	IHEADP,

+		Ttuple =>	IHEADM,

+		Texception => IHEADM,

+		Tfix =>	IHEADW,

+		Tpoly =>	IHEADP,

+

+		Tany =>		IHEADP,

+

+		* =>		0

+	},

+	Mtl  => array[Tend] of

+	{

+		Tlist =>	ITAIL,

+

+		* =>		0

+	},

+};

+

+chantab := array[Tend] of

+{

+	Tadt =>		INEWCM,

+	Tadtpick =>	0,

+	Tarray =>	INEWCP,

+	Tbig =>		INEWCL,

+	Tbyte =>	INEWCB,

+	Tchan =>	INEWCP,

+	Treal =>	INEWCF,

+	Tint =>		INEWCW,

+	Tlist =>	INEWCP,

+	Tmodule =>	INEWCP,

+	Tref =>		INEWCP,

+	Tstring =>	INEWCP,

+	Ttuple =>	INEWCM,

+	Texception => INEWCM,

+	Tfix =>	INEWCW,

+	Tpoly =>	INEWCP,

+

+	Tany =>		INEWCP,

+

+	* =>	0

+};

+

+opind := array[Tend] of

+{

+	Tbyte =>	1,

+	Tint =>		2,

+	Tbig =>		3,

+	Treal =>	4,

+	Tstring =>	5,

+	Tfix => 6,

+

+	* =>		0

+};

+

+disoptab := array[Oend+1] of

+{

+	# opcode			default	byte	word	big	real	string	fixed

+	Oadd =>		array[7] of	{0,	IADDB,	IADDW,	IADDL,	IADDF,	IADDC,	IADDW,},

+	Oaddas =>	array[7] of	{0,	IADDB,	IADDW,	IADDL,	IADDF,	IADDC,	IADDW,},

+	Oand =>		array[7] of	{0,	IANDB,	IANDW,	IANDL,	0,	0,	0,},

+	Oandas =>	array[7] of	{0,	IANDB,	IANDW,	IANDL,	0, 	0,	0,},

+	Odec =>		array[7] of	{0,	ISUBB,	ISUBW,	ISUBL,	ISUBF,	0,	ISUBW,},

+	Odiv =>		array[7] of	{0,	IDIVB,	IDIVW,	IDIVL,	IDIVF,	0,	IDIVX,},

+	Odivas =>	array[7] of	{0,	IDIVB,	IDIVW,	IDIVL,	IDIVF,	0,	IDIVX,},

+	Oeq =>		array[7] of	{IBEQW,	IBEQB,	IBEQW,	IBEQL,	IBEQF,	IBEQC,	IBEQW,},

+	Oexp =>	array[7] of	{0,	0,	IEXPW,	IEXPL,	IEXPF,	0,	0,},

+	Oexpas =>	array[7] of	{0,	0,	IEXPW,	IEXPL,	IEXPF,	0,	0,},

+	Ogeq =>		array[7] of	{0,	IBGEB,	IBGEW,	IBGEL,	IBGEF,	IBGEC,	IBGEW,},

+	Ogt =>		array[7] of	{0,	IBGTB,	IBGTW,	IBGTL,	IBGTF,	IBGTC,	IBGTW,},

+	Oinc =>		array[7] of	{0,	IADDB,	IADDW,	IADDL,	IADDF,	0,	IADDW,},

+	Oinds =>	array[7] of	{0,	0,	IINDC,	0,	0,	0,	0,},

+	Oindx =>	array[7] of	{0,	0,	IINDX,	0,	0,	0,	0,},

+	Olen =>		array[7] of	{ILENA,	0,	0,	0,	0,	ILENC,	0,},

+	Oleq =>		array[7] of	{0,	IBLEB,	IBLEW,	IBLEL,	IBLEF,	IBLEC,	IBLEW,},

+	Olsh =>		array[7] of	{0,	ISHLB,	ISHLW,	ISHLL,	0,	0,	0,},

+	Olshas =>	array[7] of	{0,	ISHLB,	ISHLW,	ISHLL,	0,	0,	0,},

+	Olt =>		array[7] of	{0,	IBLTB,	IBLTW,	IBLTL,	IBLTF,	IBLTC,	IBLTW,},

+	Omod =>		array[7] of	{0,	IMODB,	IMODW,	IMODL,	0,	0,	0,},

+	Omodas =>	array[7] of	{0,	IMODB,	IMODW,	IMODL,	0,	0,	0,},

+	Omul =>		array[7] of	{0,	IMULB,	IMULW,	IMULL,	IMULF,	0,	IMULX,},

+	Omulas =>	array[7] of	{0,	IMULB,	IMULW,	IMULL,	IMULF,	0,	IMULX,},

+	Oneg =>		array[7] of	{0,	0,	0,	0,	INEGF,	0,	0, },

+	Oneq =>		array[7] of	{IBNEW,	IBNEB,	IBNEW,	IBNEL,	IBNEF,	IBNEC,	IBNEW,},

+	Oor =>		array[7] of	{0,	IORB,	IORW,	IORL,	0,	0,	0,},

+	Ooras =>	array[7] of	{0,	IORB,	IORW,	IORL,	0,	0,	0,},

+	Orsh =>		array[7] of	{0,	ISHRB,	ISHRW,	ISHRL,	0,	0,	0,},

+	Orshas =>	array[7] of	{0,	ISHRB,	ISHRW,	ISHRL,	0,	0,	0,},

+	Oslice =>	array[7] of	{ISLICEA,0,	0,	0,	0,	ISLICEC,	0,},

+	Osub =>		array[7] of	{0,	ISUBB,	ISUBW,	ISUBL,	ISUBF,	0,	ISUBW,},

+	Osubas =>	array[7] of	{0,	ISUBB,	ISUBW,	ISUBL,	ISUBF,	0,	ISUBW,},

+	Oxor =>		array[7] of	{0,	IXORB,	IXORW,	IXORL,	0,	0,	0,},

+	Oxoras =>	array[7] of	{0,	IXORB,	IXORW,	IXORL,	0,	0,	0,},

+};

+

+isbyteinst := array [256] of

+{

+	IMULB	=> 1,

+	ISUBB	=> 1,

+	IADDB	=> 1,

+	IDIVB	=> 1,

+	IORB	=> 1,

+	IXORB	=> 1,

+	ISHLB	=> 1,

+	ISHRB	=> 1,

+	IMODB	=> 1,

+	IANDB	=> 1,

+	IBEQB	=> 1,

+	IBNEB	=> 1,

+	IBLTB	=> 1,

+	IBLEB	=> 1,

+	IBGTB	=> 1,

+	IBGEB	=> 1,

+

+	*	=> 0,

+};

+

+instname := array[256] of

+{

+	"nop",

+	"alt",

+	"nbalt",

+	"goto",

+	"call",

+	"frame",

+	"spawn",

+	"runt",

+	"load",

+	"mcall",

+	"mspawn",

+	"mframe",

+	"ret",

+	"jmp",

+	"case",

+	"exit",

+	"new",

+	"newa",

+	"newcb",

+	"newcw",

+	"newcf",

+	"newcp",

+	"newcm",

+	"newcmp",

+	"send",

+	"recv",

+	"consb",

+	"consw",

+	"consp",

+	"consf",

+	"consm",

+	"consmp",

+	"headb",

+	"headw",

+	"headp",

+	"headf",

+	"headm",

+	"headmp",

+	"tail",

+	"lea",

+	"indx",

+	"movp",

+	"movm",

+	"movmp",

+	"movb",

+	"movw",

+	"movf",

+	"cvtbw",

+	"cvtwb",

+	"cvtfw",

+	"cvtwf",

+	"cvtca",

+	"cvtac",

+	"cvtwc",

+	"cvtcw",

+	"cvtfc",

+	"cvtcf",

+	"addb",

+	"addw",

+	"addf",

+	"subb",

+	"subw",

+	"subf",

+	"mulb",

+	"mulw",

+	"mulf",

+	"divb",

+	"divw",

+	"divf",

+	"modw",

+	"modb",

+	"andb",

+	"andw",

+	"orb",

+	"orw",

+	"xorb",

+	"xorw",

+	"shlb",

+	"shlw",

+	"shrb",

+	"shrw",

+	"insc",

+	"indc",

+	"addc",

+	"lenc",

+	"lena",

+	"lenl",

+	"beqb",

+	"bneb",

+	"bltb",

+	"bleb",

+	"bgtb",

+	"bgeb",

+	"beqw",

+	"bnew",

+	"bltw",

+	"blew",

+	"bgtw",

+	"bgew",

+	"beqf",

+	"bnef",

+	"bltf",

+	"blef",

+	"bgtf",

+	"bgef",

+	"beqc",

+	"bnec",

+	"bltc",

+	"blec",

+	"bgtc",

+	"bgec",

+	"slicea",

+	"slicela",

+	"slicec",

+	"indw",

+	"indf",

+	"indb",

+	"negf",

+	"movl",

+	"addl",

+	"subl",

+	"divl",

+	"modl",

+	"mull",

+	"andl",

+	"orl",

+	"xorl",

+	"shll",

+	"shrl",

+	"bnel",

+	"bltl",

+	"blel",

+	"bgtl",

+	"bgel",

+	"beql",

+	"cvtlf",

+	"cvtfl",

+	"cvtlw",

+	"cvtwl",

+	"cvtlc",

+	"cvtcl",

+	"headl",

+	"consl",

+	"newcl",

+	"casec",

+	"indl",

+	"movpc",

+	"tcmp",

+	"mnewz",

+	"cvtrf",

+	"cvtfr",

+	"cvtws",

+	"cvtsw",

+	"lsrw",

+	"lsrl",

+	"eclr",

+	"newz",

+	"newaz",

+	"raise",

+	"casel",

+	"mulx",

+	"divx",

+	"cvtxx",

+	"mulx0",

+	"divx0",

+	"cvtxx0",

+	"mulx1",

+	"divx1",

+	"cvtxx1",

+	"cvtfx",

+	"cvtxf",

+	"expw",

+	"expl",

+	"expf",

+	"self",

+};

--- /dev/null

+++ b/appl/cmd/limbo/sbl.b

@@ -1,0 +1,397 @@

+

+sbltname := array[Tend] of

+{

+	Tnone =>	byte 'n',

+	Tadt =>		byte 'a',

+	Tadtpick =>	byte 'a',

+	Tarray =>	byte 'A',

+	Tbig =>		byte 'B',

+	Tbyte =>	byte 'b',

+	Tchan =>	byte 'C',

+	Treal =>	byte 'f',

+	Tfn =>		byte 'F',

+	Tint =>		byte 'i',

+	Tlist =>	byte 'L',

+	Tmodule =>	byte 'm',

+	Tref =>		byte 'R',

+	Tstring =>	byte 's',

+	Ttuple =>	byte 't',

+	Texception => byte 't',

+	Tfix => byte 'i',

+	Tpoly => byte 'P',

+

+	Tainit =>	byte '?',

+	Talt =>		byte '?',

+	Tany =>		byte 'N',

+	Tarrow =>	byte '?',

+	Tcase =>	byte '?',

+	Tcasel =>	byte '?',

+	Tcasec =>	byte '?',

+	Tdot =>		byte '?',

+	Terror =>	byte '?',

+	Tgoto =>	byte '?',

+	Tid =>		byte '?',

+	Tiface =>	byte '?',

+	Texcept => byte '?',

+	Tinst => byte '?',

+};

+sbltadtpick:	con byte 'p';

+

+sfiles:		ref Sym;

+ftail:		ref Sym;

+nsfiles:	int;

+blockid:	int;

+lastf:		int;

+lastline:	int;

+

+MAXSBLINT:	con 12;

+MAXSBLSRC:	con 6*(MAXSBLINT+1);

+

+sblmod(m: ref Decl)

+{

+	bsym.puts("limbo .sbl 2.1\n");

+	bsym.puts(m.sym.name);

+	bsym.putb(byte '\n');

+

+	blockid = 0;

+	nsfiles = 0;

+	sfiles = ftail = nil;

+	lastf = 0;

+	lastline = 0;

+}

+

+sblfile(name: string): int

+{

+	i := 0;

+	for(s := sfiles; s != nil; s = s.next){

+		if(s.name == name)

+			return i;

+		i++;

+	}

+	s = ref Sym;

+	s.name = name;

+	s.next = nil;

+	if(sfiles == nil)

+		sfiles = s;

+	else

+		ftail.next = s;

+	ftail = s;

+	nsfiles = i + 1;

+	return i;

+}

+

+filename(s: string): string

+{

+	(nil, file) := str->splitr(s, "/ \\");

+	return file;

+}

+

+sblfiles()

+{

+	for(i := 0; i < nfiles; i++)

+		files[i].sbl = sblfile(files[i].name);

+	bsym.puts(string nsfiles);

+	bsym.putb(byte '\n');

+	for(s := sfiles; s != nil; s = s.next){

+		bsym.puts(filename(s.name));

+		bsym.putb(byte '\n');

+	}

+}

+

+sblint(buf: array of byte, off, v: int): int

+{

+	if(v == 0){

+		buf[off++] = byte '0';

+		return off;

+	}

+	stop := off + MAXSBLINT;

+	if(v < 0){

+		buf[off++] = byte '-';

+		v = -v;

+	}

+	n := stop;

+	while(v > 0){

+		buf[n -= 1] = byte(v % 10 + '0');

+		v = v / 10;

+	}

+	while(n < stop)

+		buf[off++] = buf[n++];

+	return off;

+}

+

+sblsrcconvb(buf: array of byte, off: int, src: Src): int

+{

+	(startf, startl) := fline(src.start >> PosBits);

+	(stopf, stopl) := fline(src.stop >> PosBits);

+	if(lastf != startf.sbl){

+		off = sblint(buf, off, startf.sbl);

+		buf[off++] = byte ':';

+	}

+	if(lastline != startl){

+		off = sblint(buf, off, startl);

+		buf[off++] = byte '.';

+	}

+	off = sblint(buf, off, (src.start & PosMask));

+	buf[off++] = byte ',';

+	if(startf.sbl != stopf.sbl){

+		off = sblint(buf, off, stopf.sbl);

+		buf[off++] = byte ':';

+	}

+	if(startl != stopl){

+		off = sblint(buf, off, stopl);

+		buf[off++] = byte '.';

+	}

+	off = sblint(buf, off, (src.stop & PosMask));

+	buf[off++] = byte ' ';

+	lastf = stopf.sbl;

+	lastline = stopl;

+	return off;

+}

+

+sblsrcconv(src: Src): string

+{

+	s := "";

+	(startf, startl) := fline(src.start >> PosBits);

+	(stopf, stopl) := fline(src.stop >> PosBits);

+	if(lastf != startf.sbl){

+		s += string startf.sbl;

+		s[len s] = ':';

+	}

+	if(lastline != startl){

+		s += string startl;

+		s[len s] = '.';

+	}

+	s += string (src.start & PosMask);

+	s[len s] = ',';

+	if(startf.sbl != stopf.sbl){

+		s += string stopf.sbl;

+		s[len s] = ':';

+	}

+	if(startl != stopl){

+		s += string stopl;

+		s[len s] = '.';

+	}

+	s += string (src.stop & PosMask);

+	s[len s] = ' ';

+	lastf = stopf.sbl;

+	lastline = stopl;

+	return s;

+}

+

+isnilsrc(s: Src): int

+{

+	return s.start == 0 && s.stop == 0;

+}

+

+isnilstopsrc(s: Src): int

+{

+	return s.stop == 0;

+}

+

+sblinst(in: ref Inst, ninst: int)

+{

+	src: Src;

+

+	MAXSBL:	con 8*1024;

+	buf := array[MAXSBL] of byte;

+	n := 0;

+	bsym.puts(string ninst);

+	bsym.putb(byte '\n');

+	sblblocks := array[nblocks] of {* => -1};

+	for(; in != nil; in = in.next){

+		if(in.op == INOOP)

+			continue;

+		if(in.src.start < 0)

+			fatal("no file specified for "+instconv(in));

+		if(n >= (MAXSBL - MAXSBLSRC - MAXSBLINT - 1)){

+			bsym.write(buf, n);

+			n = 0;

+		}

+		if(isnilsrc(in.src))

+			in.src = src;

+		else if(isnilstopsrc(in.src)){	# how does this happen ?

+			in.src.stop = in.src.start;

+			in.src.stop++;

+		}

+		n = sblsrcconvb(buf, n, in.src);

+		src = in.src;

+		b := sblblocks[in.block];

+		if(b < 0)

+			sblblocks[in.block] = b = blockid++;

+		n = sblint(buf, n, b);

+		buf[n++] = byte '\n';

+	}

+	if(n > 0)

+		bsym.write(buf, n);

+}

+

+sblty(tys: array of ref Decl, ntys: int)

+{

+	bsym.puts(string ntys);

+	bsym.putb(byte '\n');

+	for(i := 0; i < ntys; i++){

+		d := tys[i];

+		d.ty.sbl = i;

+	}

+	for(i = 0; i < ntys; i++){

+		d := tys[i];

+		sbltype(d.ty, 1);

+	}

+}

+

+sblfn(fns: array of ref Decl, nfns: int)

+{

+	bsym.puts(string nfns);

+	bsym.putb(byte '\n');

+	for(i := 0; i < nfns; i++){

+		f := fns[i];

+		if(ispoly(f))

+			rmfnptrs(f);

+		bsym.puts(string f.pc.pc);

+		bsym.putb(byte ':');

+		if(f.dot != nil && f.dot.ty.kind == Tadt){

+			bsym.puts(f.dot.sym.name);

+			bsym.putb(byte '.');

+		}

+		bsym.puts(f.sym.name);

+		bsym.putb(byte '\n');

+		sbldecl(f.ty.ids, Darg);

+		sbldecl(f.locals, Dlocal);

+		sbltype(f.ty.tof, 0);

+	}

+}

+

+sblvar(vars: ref Decl)

+{

+	sbldecl(vars, Dglobal);

+}

+

+isvis(id: ref Decl): int

+{

+	if(!tattr[id.ty.kind].vis

+	|| id.sym == nil

+	|| id.sym.name == ""

+	|| id.sym.name[0] == '.')

+		return 0;

+	if(id.ty == tstring && id.init != nil && id.init.op == Oconst)

+		return 0;

+	if(id.src.start < 0 || id.src.stop < 0)

+		return 0;

+	return 1;

+}

+

+sbldecl(ids: ref Decl, store: int)

+{

+	n := 0;

+	for(id := ids; id != nil; id = id.next){

+		if(id.store != store || !isvis(id))

+			continue;

+		n++;

+	}

+	bsym.puts(string n);

+	bsym.putb(byte '\n');

+	for(id = ids; id != nil; id = id.next){

+		if(id.store != store || !isvis(id))

+			continue;

+		bsym.puts(string id.offset);

+		bsym.putb(byte ':');

+		bsym.puts(id.sym.name);

+		bsym.putb(byte ':');

+		bsym.puts(sblsrcconv(id.src));

+		sbltype(id.ty, 0);

+		bsym.putb(byte '\n');

+	}

+}

+

+sbltype(t: ref Type, force: int)

+{

+	if(t.kind == Tadtpick)

+		t = t.decl.dot.ty;

+

+	d := t.decl;

+	if(!force && d != nil && d.ty.sbl >= 0){

+		bsym.putb(byte '@');

+		bsym.puts(string d.ty.sbl);

+		bsym.putb(byte '\n');

+		return;

+	}

+

+	if(t.rec != byte 0)

+		fatal("recursive sbl type: "+typeconv(t));

+

+	t.rec = byte 1;

+	case t.kind{

+	* =>

+		fatal("bad type in sbltype: "+typeconv(t));

+	Tnone or

+	Tany or

+	Tint or

+	Tbig or

+	Tbyte or

+	Treal or

+	Tstring or

+	Tfix or

+	Tpoly =>

+		bsym.putb(sbltname[t.kind]);

+	Tfn =>

+		bsym.putb(sbltname[t.kind]);

+		sbldecl(t.ids, Darg);

+		sbltype(t.tof, 0);

+	Tarray or

+	Tlist or

+	Tchan or

+	Tref =>

+		bsym.putb(sbltname[t.kind]);

+		if(t.kind == Tref && t.tof.kind == Tfn){

+			tattr[Tany].vis = 1;

+			sbltype(tfnptr, 0);

+			tattr[Tany].vis = 0;

+		}

+		else

+			sbltype(t.tof, 0);

+	Ttuple or

+	Texception =>

+		bsym.putb(sbltname[t.kind]);

+		bsym.puts(string t.size);

+		bsym.putb(byte '.');

+		sbldecl(t.ids, Dfield);

+	Tadt =>

+		if(t.tags != nil)

+			bsym.putb(sbltadtpick);

+		else

+			bsym.putb(sbltname[t.kind]);

+		if(d.dot != nil && !isimpmod(d.dot.sym))

+			bsym.puts(d.dot.sym.name + "->");

+		bsym.puts(d.sym.name);

+		bsym.putb(byte ' ');

+		bsym.puts(sblsrcconv(d.src));

+		bsym.puts(string d.ty.size);

+		bsym.putb(byte '\n');

+		sbldecl(t.ids, Dfield);

+		if(t.tags != nil){

+			bsym.puts(string t.decl.tag);

+			bsym.putb(byte '\n');

+			lastt : ref Type = nil;

+			for(tg := t.tags; tg != nil; tg = tg.next){

+				bsym.puts(tg.sym.name);

+				bsym.putb(byte ':');

+				bsym.puts(sblsrcconv(tg.src));

+				if(lastt == tg.ty){

+					bsym.putb(byte '\n');

+				}else{

+					bsym.puts(string tg.ty.size);

+					bsym.putb(byte '\n');

+					sbldecl(tg.ty.ids, Dfield);

+				}

+				lastt = tg.ty;

+			}

+		}

+	Tmodule =>

+		bsym.putb(sbltname[t.kind]);

+		bsym.puts(d.sym.name);

+		bsym.putb(byte '\n');

+		bsym.puts(sblsrcconv(d.src));

+		sbldecl(t.ids, Dglobal);

+	}

+	t.rec = byte 0;

+}

--- /dev/null

+++ b/appl/cmd/tac.b

@@ -1,0 +1,58 @@

+implement Tac;

+

+include "sys.m"; sys: Sys;

+include "bufio.m"; bufio: Bufio; Iobuf: import bufio;

+include "draw.m";

+

+Tac: module {

+	init: fn(nil: ref Draw->Context, args: list of string);

+};

+

+

+stdout: ref Sys->FD;

+

+init(nil: ref Draw->Context, args: list of string)

+{

+	sys = load Sys Sys->PATH;

+	bufio = load Bufio Bufio->PATH;

+	stdout = sys->fildes(1);

+	args = tl args;

+

+	if(args == nil)

+		args = "-" :: nil;

+

+	for(; args != nil; args = tl args) {

+		file := hd args;

+		if(file != "-") {

+			fd := sys->open(file, Sys->OREAD);

+			if(fd == nil){

+				sys->fprint(sys->fildes(2), "tac: cannot open %s: %r\n", file);

+				raise "fail:bad open";

+			}

+			tac(fd, file);

+		} else {

+			tac(sys->fildes(0), "<stdin>");

+		}

+	}

+}

+

+tac(fd: ref Sys->FD, file: string)

+{

+	lines: list of string = nil;

+	line: string;

+

+	fio := bufio->fopen(fd, bufio->OREAD);

+	if(fio == nil) {

+		sys->fprint(sys->fildes(2), "tac: Couldn't create a bufio for %s:  %r\n", file);

+		raise "fail:bufio";

+	}

+

+	while((line = fio.gets('\n')) != nil)

+		lines = line :: lines;

+

+	while(lines != nil) {

+		buf := array of byte (hd lines);

+		sys->write(stdout, buf, len buf);

+		lines = tl lines;

+	}

+}

--- /dev/null

+++ b/appl/cmd/whois.b

@@ -1,0 +1,89 @@

+implement Whois;

+

+include "sys.m"; sys: Sys;

+include "draw.m";

+include "dial.m"; dial: Dial;

+include "arg.m";

+

+Whois: module {

+	init: fn(nil: ref Draw->Context, args: list of string);

+};

+

+init(nil: ref Draw->Context, args: list of string) {

+	sys = load Sys Sys->PATH;

+	dial = load Dial Dial->PATH;

+	arg := load Arg Arg->PATH;

+

+	addr := "tcp!whois.iana.org!43";

+	expect_refer := 5;

+

+	arg->init(args);

+	arg->setusage("whois [-a addr] [-n] host");

+	while((opt := arg->opt()) != 0) {

+		case opt {

+		'a' =>

+			addr = dial->netmkaddr(arg->earg(), "tcp", "43");

+		'n' =>

+			expect_refer = 0;

+		* =>

+			arg->usage();

+		}

+	}

+

+	args = arg->argv();

+	if(len args != 1)

+		arg->usage();

+

+	host := hd args;

+	fd := whois(addr, host);

+

+	buf := array[512] of byte;

+	stdout := sys->fildes(1);

+	while((i := sys->read(fd, buf, len buf)) > 0) {

+		if(expect_refer) {

+			ls := sys->tokenize(string buf[0:i], "\n").t1;

+			newaddr: string = nil;

+			while(ls != nil) {

+				l := hd ls;

+				(n, rs) := sys->tokenize(l, " \t");

+				if(n == 2 && hd rs == "refer:") {

+					newaddr = dial->netmkaddr(hd tl rs, "tcp", "43");

+					break;

+				} else if(n == 3 && hd rs == "Whois" && hd tl rs == "Server:") {

+					newaddr = dial->netmkaddr(hd tl tl rs, "tcp", "43");

+					break;

+				}

+				ls = tl ls;

+			}

+			if(newaddr != nil) {

+				fd = whois(newaddr, host);

+				expect_refer--;

+				continue;

+			}

+		}

+		sys->write(stdout, buf, i);

+	}

+	if(i < 0) {

+		sys->fprint(sys->fildes(2), "whois: reading info: %r\n");

+		raise "fail:errors";

+	}

+}

+

+whois(addr: string, host: string): ref Sys->FD

+{

+	sys->print("[using server %s]\n", addr);

+	conn := dial->dial(addr, nil);

+	if(conn == nil) {

+		sys->fprint(sys->fildes(2), "whois: dialing %s: %r\n", addr);

+		raise "fail:errors";

+	}

+

+	fd := conn.dfd;

+	i := sys->fprint(fd, "%s\r\n", host);

+	if(i != len host + 2) {

+		sys->fprint(sys->fildes(2), "whois: sending name: %r\n");

+		raise "fail:errors";

+	}

+

+	return fd;

+}

--- /dev/null

+++ b/appl/lib/dis.b

@@ -1,0 +1,609 @@

+implement Dis;

+

+#

+# Derived by Vita Nuova Limited 1998 from /appl/wm/rt.b, which is

+# Copyright © 1996-1999 Lucent Technologies Inc.  All rights reserved.

+#

+

+include "sys.m";

+	sys: Sys;

+	sprint: import sys;

+

+include "math.m";

+	math: Math;

+

+include "dis.m";

+

+disptr: int;

+disobj: array of byte;

+

+optab := array[] of {

+	"nop",

+	"alt",

+	"nbalt",

+	"goto",

+	"call",

+	"frame",

+	"spawn",

+	"runt",

+	"load",

+	"mcall",

+	"mspawn",

+	"mframe",

+	"ret",

+	"jmp",

+	"case",

+	"exit",

+	"new",

+	"newa",

+	"newcb",

+	"newcw",

+	"newcf",

+	"newcp",

+	"newcm",

+	"newcmp",

+	"send",

+	"recv",

+	"consb",

+	"consw",

+	"consp",

+	"consf",

+	"consm",

+	"consmp",

+	"headb",

+	"headw",

+	"headp",

+	"headf",

+	"headm",

+	"headmp",

+	"tail",

+	"lea",

+	"indx",

+	"movp",

+	"movm",

+	"movmp",

+	"movb",

+	"movw",

+	"movf",

+	"cvtbw",

+	"cvtwb",

+	"cvtfw",

+	"cvtwf",

+	"cvtca",

+	"cvtac",

+	"cvtwc",

+	"cvtcw",

+	"cvtfc",

+	"cvtcf",

+	"addb",

+	"addw",

+	"addf",

+	"subb",

+	"subw",

+	"subf",

+	"mulb",

+	"mulw",

+	"mulf",

+	"divb",

+	"divw",

+	"divf",

+	"modw",

+	"modb",

+	"andb",

+	"andw",

+	"orb",

+	"orw",

+	"xorb",

+	"xorw",

+	"shlb",

+	"shlw",

+	"shrb",

+	"shrw",

+	"insc",

+	"indc",

+	"addc",

+	"lenc",

+	"lena",

+	"lenl",

+	"beqb",

+	"bneb",

+	"bltb",

+	"bleb",

+	"bgtb",

+	"bgeb",

+	"beqw",

+	"bnew",

+	"bltw",

+	"blew",

+	"bgtw",

+	"bgew",

+	"beqf",

+	"bnef",

+	"bltf",

+	"blef",

+	"bgtf",

+	"bgef",

+	"beqc",

+	"bnec",

+	"bltc",

+	"blec",

+	"bgtc",

+	"bgec",

+	"slicea",

+	"slicela",

+	"slicec",

+	"indw",

+	"indf",

+	"indb",

+	"negf",

+	"movl",

+	"addl",

+	"subl",

+	"divl",

+	"modl",

+	"mull",

+	"andl",

+	"orl",

+	"xorl",

+	"shll",

+	"shrl",

+	"bnel",

+	"bltl",

+	"blel",

+	"bgtl",

+	"bgel",

+	"beql",

+	"cvtlf",

+	"cvtfl",

+	"cvtlw",

+	"cvtwl",

+	"cvtlc",

+	"cvtcl",

+	"headl",

+	"consl",

+	"newcl",

+	"casec",

+	"indl",

+	"movpc",

+	"tcmp",

+	"mnewz",

+	"cvtrf",

+	"cvtfr",

+	"cvtws",

+	"cvtsw",

+	"lsrw",

+	"lsrl",

+	"eclr",

+	"newz",

+	"newaz",

+	"raise",

+	"casel",

+	"mulx",

+	"divx",

+	"cvtxx",

+	"mulx0",

+	"divx0",

+	"cvtxx0",

+	"mulx1",

+	"divx1",

+	"cvtxx1",

+	"cvtfx",

+	"cvtxf",

+	"expw",

+	"expl",

+	"expf",

+	"self",

+};

+

+init()

+{

+	sys = load Sys  Sys->PATH;

+	math = load Math Math->PATH;	# optional

+}

+

+loadobj(disfile: string): (ref Mod, string)

+{

+	fd := sys->open(disfile, sys->OREAD);

+	if(fd == nil)

+		return (nil, "open failed: "+sprint("%r"));

+

+	(ok, d) := sys->fstat(fd);

+	if(ok < 0)

+		return (nil, "stat failed: "+sprint("%r"));

+

+	objlen := int d.length;

+	disobj = array[objlen] of byte;

+

+	if(sys->read(fd, disobj, objlen) != objlen){

+		disobj = nil;

+		return (nil, "read failed: "+sprint("%r"));

+	}

+

+	disptr = 0;

+	m := ref Mod;

+	m.magic = operand();

+	if(m.magic == SMAGIC) {

+		n := operand();

+		m.sign = disobj[disptr:disptr+n];

+		disptr += n;

+		m.magic = operand();

+	}

+	if(m.magic != XMAGIC){

+		disobj = nil;

+		return (nil, "bad magic number");

+	}

+

+	m.rt = operand();

+	m.ssize = operand();

+	m.isize = operand();

+	m.dsize = operand();

+	m.tsize = operand();

+	m.lsize = operand();

+	m.entry = operand();

+	m.entryt = operand();

+

+	m.inst = array[m.isize] of ref Inst;

+	for(i := 0; i < m.isize; i++) {

+		o := ref Inst;

+		o.op = int disobj[disptr++];

+		o.addr = int disobj[disptr++];

+		case o.addr & ARM {

+		AXIMM or

+		AXINF or

+		AXINM =>

+			o.mid = operand();

+		}

+

+		case (o.addr>>3) & 7 {

+		AFP or

+		AMP or

+		AIMM =>

+			o.src = operand();

+		AIND|AFP or

+		AIND|AMP =>

+			o.src = operand()<<16;

+			o.src |= operand();

+		}

+

+		case o.addr & 7	 {

+		AFP or

+		AMP or

+		AIMM =>

+			o.dst = operand();

+		AIND|AFP or

+		AIND|AMP =>

+			o.dst = operand()<<16;

+			o.dst |= operand();

+		}

+		m.inst[i] = o;

+	}

+

+	m.types = array[m.tsize] of ref Type;

+	for(i = 0; i < m.tsize; i++) {

+		h := ref Type;

+		id := operand();

+		h.size = operand();

+		h.np = operand();

+		h.map = disobj[disptr:disptr+h.np];

+		disptr += h.np;

+		m.types[i] = h;

+	}

+

+	for(;;) {

+		op := int disobj[disptr++];

+		if(op == 0)

+			break;

+

+		n := op & (DMAX-1);

+		if(n == 0)

+			n = operand();

+

+		offset := operand();

+

+		dat: ref Data;

+		case op>>4 {

+		DEFB =>

+			dat = ref Data.Bytes(op, n, offset, disobj[disptr:disptr+n]);

+			disptr += n;

+		DEFW =>

+			words := array[n] of int;

+			for(i = 0; i < n; i++)

+				words[i] = getw();

+			dat = ref Data.Words(op, n, offset, words);

+		DEFS =>

+			dat = ref Data.String(op, n, offset, string disobj[disptr:disptr+n]);

+			disptr += n;

+		DEFF =>

+			if(math != nil){

+				reals := array[n] of real;

+				for(i = 0; i < n; i++)

+					reals[i] = math->bits64real(getl());

+				dat = ref Data.Reals(op, n, offset, reals);

+			} else {

+				disptr += 8*n;	# skip it

+				dat = ref Data.Reals(op, n, offset, nil);

+			}

+			break;

+		DEFA =>

+			typex := getw();

+			length := getw();

+			dat = ref Data.Array(op, n, offset, typex, length);

+		DIND =>

+			dat = ref Data.Aindex(op, n, offset, getw());

+		DAPOP =>

+			dat = ref Data.Arestore(op, n, offset);

+		DEFL =>

+			bigs := array[n] of big;

+			for(i = 0; i < n; i++)

+				bigs[i] = getl();

+			dat = ref Data.Bigs(op, n, offset, bigs);

+		* =>

+			dat = ref Data.Zero(op, n, offset);

+		}

+		m.data = dat :: m.data;

+	}

+

+	m.data = revdat(m.data);

+

+	m.name = gets();

+

+	m.links = array[m.lsize] of ref Link;

+	for(i = 0; i < m.lsize; i++) {

+		l := ref Link;

+		l.pc = operand();

+		l.desc = operand();

+		l.sig = getw();

+		l.name = gets();

+

+		m.links[i] = l;

+	}

+

+	if(m.rt & Dis->HASLDT0)

+		raise "obsolete dis";

+

+	if(m.rt & Dis->HASLDT){

+		nl := operand();

+		imps := array[nl] of array of ref Import;

+		for(i = 0; i < nl; i++){

+			n := operand();

+			imps[i] = array[n] of ref Import;

+			for(j := 0; j < n; j++){

+				imps[i][j] = im := ref Import;

+				im.sig = getw();

+				im.name = gets();

+			}

+		}

+		disptr++;

+		m.imports = imps;

+	}

+

+	if(m.rt & Dis->HASEXCEPT){

+		nh := operand();	# number of handlers

+		hs := array[nh] of ref Handler;

+		for(i = 0; i < nh; i++){

+			h := hs[i] = ref Handler;

+			h.eoff = operand();

+			h.pc1 = operand();

+			h.pc2 = operand();

+			t := operand();

+			if(t >= 0)

+				h.t = m.types[t];

+			n := operand();	

+			h.ne = n>>16;

+			n &= 16rffff;	# number of cases

+			h.etab = array[n+1] of ref Except;

+			for(j := 0; j < n; j++){

+				e := h.etab[j] = ref Except;

+				k := disptr;

+				while(int disobj[disptr++])	# pattern

+					;

+				e.s = string disobj[k: disptr-1];

+				e.pc = operand();

+			}

+			e := h.etab[j] = ref Except;

+			e.pc = operand();	# * pc

+		}

+		disptr++;	# 0 byte

+		m.handlers = hs;

+	}

+

+	m.srcpath = gets();

+

+	disobj = nil;

+	return (m, nil);

+}

+

+operand(): int

+{

+	if(disptr >= len disobj)

+		return -1;

+

+	b := int disobj[disptr++];

+

+	case b & 16rC0 {

+	16r00 =>

+		return b;

+	16r40 =>

+		return b | ~16r7F;

+	16r80 =>

+		if(disptr >= len disobj)

+			return -1;

+		if(b & 16r20)

+			b |= ~16r3F;

+		else

+			b &= 16r3F;

+		return (b<<8) | int disobj[disptr++];

+	16rC0 =>

+		if(disptr+2 >= len disobj)

+			return -1;

+		if(b & 16r20)

+			b |= ~16r3F;

+		else

+			b &= 16r3F;

+		b = b<<24 |

+			(int disobj[disptr]<<16) |

+		    	(int disobj[disptr+1]<<8)|

+		    	int disobj[disptr+2];

+		disptr += 3;

+		return b;

+	}

+	return 0;

+}

+

+get4(a: array of byte, i: int): int

+{

+	return (int a[i+0] << 24) | (int a[i+1] << 16) | (int a[i+2] << 8) | int a[i+3];

+}

+

+getw(): int

+{

+	if(disptr+3 >= len disobj)

+		return -1;

+	i := (int disobj[disptr+0]<<24) |

+	     (int disobj[disptr+1]<<16) |

+	     (int disobj[disptr+2]<<8) |

+	      int disobj[disptr+3];

+

+	disptr += 4;

+	return i;

+}

+

+getl(): big

+{

+	if(disptr+7 >= len disobj)

+		return big -1;

+	i := (big disobj[disptr+0]<<56) |

+	     (big disobj[disptr+1]<<48) |

+	     (big disobj[disptr+2]<<40) |

+	     (big disobj[disptr+3]<<32) |

+	     (big disobj[disptr+4]<<24) |

+	     (big disobj[disptr+5]<<16) |

+	     (big disobj[disptr+6]<<8) |

+	      big disobj[disptr+7];

+

+	disptr += 8;

+	return i;

+}

+

+gets(): string

+{

+	s := disptr;

+	while(disptr < len disobj && disobj[disptr] != byte 0)

+		disptr++;

+

+	v := string disobj[s:disptr];

+	disptr++;

+	return v;

+}

+

+revdat(d: list of ref Data): list of ref Data

+{

+	t: list of ref Data;

+

+	while(d != nil) {

+		t = hd d :: t;

+		d = tl d;

+	}

+	return t;

+}

+

+op2s(op: int): string

+{

+	if(op < 0 || op >= len optab)

+		return sys->sprint("OP%d", op);

+	return optab[op];

+}

+

+inst2s(o: ref Inst): string

+{

+	fi := 0;

+	si := 0;

+	s := sprint("%-10s", optab[o.op]);

+	src := "";

+	dst := "";

+	mid := "";

+	case (o.addr>>3) & 7 {

+	AFP =>

+		src = sprint("%d(fp)", o.src);

+	AMP =>

+		src = sprint("%d(mp)", o.src);

+	AIMM =>

+		src = sprint("$%d", o.src);

+	AIND|AFP =>

+		fi = (o.src>>16) & 16rFFFF;

+		si = o.src & 16rFFFF;

+		src = sprint("%d(%d(fp))", si, fi);

+	AIND|AMP =>

+		fi = (o.src>>16) & 16rFFFF;

+		si = o.src & 16rFFFF;

+		src = sprint("%d(%d(mp))", si, fi);

+	}

+

+	case o.addr & ARM {

+	AXIMM =>

+		mid = sprint("$%d", o.mid);

+	AXINF =>

+		mid = sprint("%d(fp)", o.mid);

+	AXINM =>

+		mid = sprint("%d(mp)", o.mid);

+	}

+

+	case o.addr & 7 {

+	AFP =>

+		dst = sprint("%d(fp)", o.dst);

+	AMP =>

+		dst = sprint("%d(mp)", o.dst);

+	AIMM =>

+		dst = sprint("$%d", o.dst);

+	AIND|AFP =>

+		fi = (o.dst>>16) & 16rFFFF;

+		si = o.dst & 16rFFFF;

+		dst = sprint("%d(%d(fp))", si, fi);

+	AIND|AMP =>

+		fi = (o.dst>>16) & 16rFFFF;

+		si = o.dst & 16rFFFF;

+		dst = sprint("%d(%d(mp))", si, fi);

+	}

+	if(mid == "") {

+		if(src == "")

+			s += sprint("%s", dst);

+		else if(dst == "")

+			s += sprint("%s", src);

+		else

+			s += sprint("%s, %s", src, dst);

+	}

+	else

+		s += sprint("%s, %s, %s", src, mid, dst);

+

+	return s;

+}

+

+getsb(fd: ref Sys->FD, o: int): (string, int)

+{

+	b := array[1] of byte;

+	buf := array[8192] of byte;

+	p := len buf;

+	for( ; ; o++){

+		sys->seek(fd, big -o, Sys->SEEKEND);

+		if(sys->read(fd, b, 1) != 1)

+			return (nil, 0);

+		if(b[0] == byte 0){

+			if(p < len buf)

+				break;

+		}

+		else if(p > 0)

+			buf[--p] = b[0];

+	}

+	return (string buf[p: ], o);

+}

+

+src(disf: string): string

+{

+	fd := sys->open(disf, sys->OREAD);

+	if(fd == nil)

+		return nil;

+	(s, nil) := getsb(fd, 1);

+	if(s != nil && s[0] == '/')

+		return s;

+	return nil;

+}

--- /dev/null

+++ b/appl/lib/diskblocks.b

@@ -1,0 +1,122 @@

+implement Diskblocks;

+

+#

+# adapted from Acme's disk.b

+#

+

+include "sys.m";

+	sys: Sys;

+

+include "diskblocks.m";

+

+init()

+{

+	sys = load Sys Sys->PATH;

+}

+

+tempfile(): ref Sys->FD

+{

+	user := "inferno";

+	fd := sys->open("/dev/user", Sys->OREAD);

+	if(fd != nil){

+		b := array[Sys->NAMEMAX] of byte;

+		n := sys->read(fd, b, len b);

+		if(n > 0)

+			user = string b[0:n];

+	}

+	fd = nil;

+	buf := sys->sprint("/tmp/X%d.%.4sblks", sys->pctl(0, nil), user);

+	for(i:='A'; i<='Z'; i++){

+		buf[5] = i;

+		if(sys->stat(buf).t0 == 0)

+			continue;

+		fd = sys->create(buf, Sys->ORDWR|Sys->ORCLOSE|Sys->OEXCL, 8r600);

+		if(fd != nil)

+			return fd;

+	}

+	return nil;

+}

+

+Disk.init(fd: ref Sys->FD, gran: int, maxblock: int): ref Disk

+{

+	d := ref Disk;

+	if(gran == 0 || maxblock%gran != 0)

+		return nil;

+	d.maxblock = maxblock;

+	d.gran = gran;

+	d.free = array[maxblock/gran+1] of list of ref Block;

+	d.addr = big 0;

+	d.fd = fd;

+	d.lock = chan[1] of int;

+	return d;

+}

+

+ntosize(d: ref Disk, n: int): (int, int)

+{

+	if (n > d.maxblock)

+		return (-1, -1);

+	size := n;

+	if((size % d.gran) != 0)

+		size += d.gran - size%d.gran;

+	# last bucket holds blocks of exactly d.maxblock

+	return (size, size/d.gran);

+}

+

+Disk.new(d: self ref Disk, n: int): ref Block

+{

+	(size, i) := ntosize(d, n);

+	if(i < 0){

+		sys->werrstr("illegal Disk allocation");

+		return nil;

+	}

+	b: ref Block;

+	d.lock <-= 1;

+	if(d.free[i] != nil){

+		b = hd d.free[i];

+		d.free[i] = tl d.free[i];

+	}else{

+		b = ref Block(d.addr, 0);

+		d.addr += big size;

+	}

+	<-d.lock;

+	b.n = n;

+	return b;

+}

+

+Disk.release(d: self ref Disk, b: ref Block)

+{

+	(nil, i) := ntosize(d, b.n);

+	d.lock <-= 1;

+	d.free[i] = b :: d.free[i];

+	<-d.lock;

+}

+

+Disk.write(d: self ref Disk, b: ref Block, a: array of byte, n: int): ref Block

+{

+	if(b != nil){

+		(size, nil) := ntosize(d, b.n);

+		(nsize, nil) := ntosize(d, n);

+		if(size != nsize){

+			d.release(b);

+			b = d.new(n);

+		}

+	}else

+		b = d.new(n);

+	if(b == nil)

+		return nil;

+	if(sys->pwrite(d.fd, a, n, b.addr) != n){

+		sys->werrstr(sys->sprint("Disk write error: %r"));

+		return nil;

+	}

+	b.n = n;

+	return b;

+}

+

+Disk.read(d: self ref Disk, b: ref Block, a: array of byte, n: int): int

+{

+	if(b == nil || n > b.n){

+		sys->werrstr("read request bigger than block");

+		return -1;

+	}

+	return sys->pread(d.fd, a, n, b.addr);

+}

--- /dev/null

+++ b/appl/lib/disks.b

@@ -1,0 +1,363 @@

+implement Disks;

+

+# adapted from /sys/src/libdisk on Plan 9: subject to Lucent Public License 1.02

+

+include "sys.m";

+	sys: Sys;

+

+include "bufio.m";

+	bufio: Bufio;

+	Iobuf: import bufio;

+

+include "disks.m";

+

+scsiverbose := 0;

+

+Codefile: con "/lib/scsicodes";

+

+Code: adt {

+	v:	int;	# (asc<<8) | ascq

+	s:	string;

+};

+codes: array of Code;

+

+init()

+{

+	sys = load Sys Sys->PATH;

+	bufio = load Bufio Bufio->PATH;

+}

+

+#

+# Discover the disk geometry by various sleazeful means.

+# 

+# First, if there is a partition table in sector 0,

+# see if all the partitions have the same end head

+# and sector; if so, we'll assume that that's the 

+# right count.

+# 

+# If that fails, we'll try looking at the geometry that the ATA

+# driver supplied, if any, and translate that as a

+# BIOS might. 

+# 

+# If that too fails, which should only happen on a SCSI

+# disk with no currently defined partitions, we'll try

+# various common (h, s) pairs used by BIOSes when faking

+# the geometries.

+#

+

+# table entry:

+	Oactive,			# active flag

+	Ostarth,			# starting head

+	Ostarts,			# starting sector

+	Ostartc,			# starting cylinder

+	Otype,			# partition type

+	Oendh,			# ending head

+	Oends,			# ending sector

+	Oendc: con iota;		# ending cylinder

+	Oxlba: con Oendc+1;	# starting LBA from start of disc or partition [4]

+	Oxsize: con Oxlba+4;	# size in sectors[4]

+

+# Table: entry[NTentry][TentrySize] magic[2]

+Omagic: con NTentry*TentrySize;

+

+partitiongeometry(d: ref Disk): int

+{

+	buf := array[512] of byte;

+	t := buf[Toffset:];

+

+	#

+	# look for an MBR first in the /dev/sdXX/data partition, otherwise

+	# attempt to fall back on the current partition.

+	#

+	rawfd := sys->open(d.prefix+"data", Sys->OREAD);

+	if(rawfd != nil

+	&& sys->seek(rawfd, big 0, 0) == big 0

+	&& sys->readn(rawfd, buf, 512) == 512

+	&& int t[Omagic] == Magic0

+	&& int t[Omagic+1] == Magic1) {

+		rawfd = nil;

+	}else{

+		rawfd = nil;

+		if(sys->seek(d.fd, big 0, 0) < big 0

+		|| sys->readn(d.fd, buf, 512) != 512

+		|| int t[Omagic] != Magic0

+		|| int t[Omagic+1] != Magic1)

+			return -1;

+	}

+

+	h := s := -1;

+	for(i:=0; i<NTentry*TentrySize; i += TentrySize) {

+		if(t[i+Otype] == byte 0)

+			continue;

+

+		t[i+Oends] &= byte 63;

+		if(h == -1) {

+			h = int t[i+Oendh];

+			s = int t[i+Oends];

+		} else {

+			#

+			# Only accept the partition info if every

+			# partition is consistent.

+			#

+			if(h != int t[i+Oendh] || s != int t[i+Oends])

+				return -1;

+		}

+	}

+

+	if(h == -1)

+		return -1;

+

+	d.h = h+1;	# heads count from 0

+	d.s = s;	# sectors count from 1

+	d.c = int (d.secs / big (d.h*d.s));

+	d.chssrc = "part";

+	return 0;

+}

+

+#

+# If there is ATA geometry, use it, perhaps massaged

+#

+drivergeometry(d: ref Disk): int

+{

+	if(d.c == 0 || d.h == 0 || d.s == 0)

+		return -1;

+

+	d.chssrc = "disk";

+	if(d.c < 1024)

+		return 0;

+

+	case d.h {

+	15 =>

+		d.h = 255;

+		d.c /= 17;

+

+	* =>

+		for(m := 2; m*d.h < 256; m *= 2) {

+			if(d.c/m < 1024) {

+				d.c /= m;

+				d.h *= m;

+				return 0;

+			}

+		}

+

+		# set to 255, 63 and be done with it

+		d.h = 255;

+		d.s = 63;

+		d.c = int (d.secs / big(d.h * d.s));

+	}

+	return 0;

+}

+

+#

+# There's no ATA geometry and no partitions.

+# Our guess is as good as anyone's.

+#

+Guess: adt {

+	h:	int;

+	s:	int;

+};

+guess: array of Guess = array[] of {

+	(64, 32),

+	(64, 63),

+	(128, 63),

+	(255, 63),

+};

+

+guessgeometry(d: ref Disk)

+{

+	d.chssrc = "guess";

+	c := 1024;

+	for(i:=0; i<len guess; i++)

+		if(big(c*guess[i].h*guess[i].s) >= d.secs) {

+			d.h = guess[i].h;

+			d.s = guess[i].s;

+			d.c = int(d.secs / big(d.h * d.s));

+			return;

+		}

+

+	# use maximum values

+	d.h = 255;

+	d.s = 63;

+	d.c = int(d.secs / big(d.h * d.s));

+}

+

+findgeometry(disk: ref Disk)

+{

+	disk.h = disk.s = disk.c = 0;

+	if(partitiongeometry(disk) < 0 &&

+	   drivergeometry(disk) < 0)

+		guessgeometry(disk);

+}

+

+openfile(d: ref Disk): ref Disk

+{

+	(ok, db) := sys->fstat(d.fd);

+	if(ok < 0)

+		return nil;

+

+	d.secsize = 512;

+	d.size = db.length;

+	d.secs = d.size / big d.secsize;

+	d.offset = big 0;

+

+	findgeometry(d);

+	return mkwidth(d);

+}

+

+opensd(d: ref Disk): ref Disk

+{

+	b := bufio->fopen(d.ctlfd, Bufio->OREAD);

+	while((p := b.gets('\n')) != nil){

+		p = p[0:len p - 1];

+		(nf, f) := sys->tokenize(p, " \t");	# might need str->unquote

+		if(nf >= 3 && hd f == "geometry") {

+			d.secsize = int hd tl tl f;

+			if(nf >= 6) {

+				d.c = int hd tl tl tl f;

+				d.h = int hd tl tl tl tl f;

+				d.s = int hd tl tl tl tl tl f;

+			}

+		}

+		if(nf >= 4 && hd f == "part" && hd tl f == d.part) {

+			d.offset = big hd tl tl f;

+			d.secs = big hd tl tl tl f - d.offset;

+		}

+	}

+

+	

+	d.size = d.secs * big d.secsize;

+	if(d.size <= big 0) {

+		d.part = "";

+		d.dtype = "file";

+		return openfile(d);

+	}

+

+	findgeometry(d);

+	return mkwidth(d);

+}

+

+Disk.open(name: string, mode: int, noctl: int): ref Disk

+{

+	d := ref Disk;

+	d.rdonly = mode == Sys->OREAD;

+	d.fd = sys->open(name, Sys->OREAD);

+	if(d.fd == nil)

+		return nil;

+

+	if(mode != Sys->OREAD){

+		d.wfd = sys->open(name, Sys->OWRITE);

+		if(d.wfd == nil)

+			d.rdonly = 1;

+	}

+

+	if(noctl)

+		return openfile(d);

+

+	# check for floppy(3) disk

+	if(len name >= 7) {

+		q := name[len name-7:];

+		if(q[0] == 'f' && q[1] == 'd' && isdigit(q[2]) && q[3:] == "disk") {

+			if((d.ctlfd = sys->open(name[0:len name-4]+"ctl", Sys->ORDWR)) != nil) {

+				d.prefix = name[0:len name-4];	# fdN (unlike Plan 9)

+				d.dtype = "floppy";

+				return openfile(d);

+			}

+		}

+	}

+

+	# attempt to find sd(3) disk or partition

+	d.prefix = name;

+	for(i := len name; --i >= 0;)

+		if(name[i] == '/'){

+			d.prefix = name[0:i+1];

+			break;

+		}

+

+	if((d.ctlfd = sys->open(d.prefix+"ctl", Sys->ORDWR)) != nil) {

+		d.dtype = "sd";

+		d.part = name[len d.prefix:];

+		return opensd(d);

+	}

+

+	# assume we have just a normal file

+	d.dtype = "file";

+	return openfile(d);

+}

+

+mkwidth(d: ref Disk): ref Disk

+{

+	d.width = len sys->sprint("%bd", d.size);

+	return d;

+}

+

+isdigit(c: int): int

+{

+	return c >= '0' && c <= '9';

+}

+

+putchs(d: ref Disk, p: array of byte, lba: big)

+{

+	s := int (lba % big d.s);

+	h := int (lba / big d.s % big d.h);

+	c := int (lba / (big d.s * big d.h));

+

+	if(c >= 1024) {

+		c = 1023;

+		h = d.h - 1;

+		s = d.s - 1;

+	}

+

+	p[0] = byte h;

+	p[1] = byte (((s+1) & 16r3F) | ((c>>2) & 16rC0));

+	p[2] = byte c;

+}

+

+PCpart.bytes(p: self PCpart, d: ref Disk): array of byte

+{

+	a := array[TentrySize] of byte;

+	a[Oactive] = byte p.active;

+	a[Otype] = byte p.ptype;

+	putchs(d, a[Ostarth:], p.base+p.offset);

+	putchs(d, a[Oendh:], p.base+p.offset+p.size-big 1);

+	putle32(a[Oxlba:], p.offset);

+	putle32(a[Oxsize:], p.size);

+	return a;

+}

+

+PCpart.extract(a: array of byte, nil: ref Disk): PCpart

+{

+	p: PCpart;

+	p.active = int a[Oactive];

+	p.ptype = int a[Otype];

+	p.base = big 0;

+	p.offset = getle32(a[Oxlba:]);

+	p.size = getle32(a[Oxsize:]);

+	return p;

+}

+

+getle32(p: array of byte): big

+{

+	return (big p[3]<<24) | (big p[2]<<16) | (big p[1] << 8) | big p[0];

+}

+

+putle32(p: array of byte, i: big)

+{

+	p[0] = byte i;

+	p[1] = byte (i>>8);

+	p[2] = byte (i>>16);

+	p[3] = byte (i>>24);

+}

+

+Disk.readn(d: self ref Disk, buf: array of byte, nb: int): int

+{

+	return sys->readn(d.fd, buf, nb);

+}

+

+chstext(p: array of byte): string

+{

+	h := int p[0];

+	c := int p[2];

+	c |= (int p[1]&16rC0)<<2;

+	s := (int p[1] & 16r3F);

+	return sys->sprint("%d/%d/%d", c, h, s);

+}

binary files /dev/null b/appl/lib/ida/idatab.dist differ