diff --git a/usr/gri/gosrc/ast.go b/usr/gri/gosrc/ast.go
deleted file mode 100644
index 3188755..0000000
--- a/usr/gri/gosrc/ast.go
+++ /dev/null
@@ -1,218 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package AST
-
-import Globals "globals"
-import GlobalObject "object"
-import Type "type"
-import Universe "universe"
-
-
-// ----------------------------------------------------------------------------
-// Expressions
-
-const /* op */ (
-	LITERAL = iota;
-	OBJECT;
-	DEREF;
-	SELECT;
-	CALL;
-	TUPLE;
-)
-
-
-// ----------------------------------------------------------------------------
-// Literals
-
-type Literal struct {
-	pos_ int;
-	typ_ *Globals.Type;
-	b bool;
-	i int;
-	f float;
-	s string;
-}
-
-
-func (x *Literal) op() int  { return LITERAL; }
-func (x *Literal) pos() int  { return x.pos_; }
-func (x *Literal) typ() *Globals.Type  { return x.typ_; }
-
-
-func NewLiteral(pos int, typ *Globals.Type) *Literal {
-	x := new(Literal);
-	x.pos_ = pos;
-	x.typ_ = typ;
-	return x;
-}
-
-
-var Bad, True, False, Nil *Literal;
-
-
-// ----------------------------------------------------------------------------
-// Objects
-
-// NOTE We could use Globals.Object directly if we'd added a typ()
-// method to its interface. However, this would require renaming the
-// typ field everywhere... - Need to think about accessors again.
-type Object struct {
-	pos_ int;
-	obj *Globals.Object;
-}
-
-
-func (x *Object) op() int  { return OBJECT; }
-func (x *Object) pos() int  { return x.pos_; }
-func (x *Object) typ() *Globals.Type  { return x.obj.typ; }
-
-
-func NewObject(pos int, obj* Globals.Object) *Object {
-	x := new(Object);
-	x.pos_ = pos;
-	x.obj = obj;
-	return x;
-}
-
-
-// ----------------------------------------------------------------------------
-// Derefs
-
-// TODO model Deref as unary operation?
-type Deref struct {
-	ptr_ Globals.Expr;
-}
-
-
-func (x *Deref) op() int  { return DEREF; }
-func (x *Deref) pos() int { return x.ptr_.pos(); }
-func (x *Deref) typ() *Globals.Type  { return x.ptr_.typ().elt; }
-
-
-func NewDeref(ptr Globals.Expr) *Deref {
-	x := new(Deref);
-	x.ptr_ = ptr;
-	return x;
-}
-
-
-// ----------------------------------------------------------------------------
-// Selectors
-
-// TODO model Selector as binary operation?
-type Selector struct {
-	pos_ int;
-	typ_ *Globals.Type;
-}
-
-
-func (x *Selector) op() int  { return SELECT; }
-func (x *Selector) pos() int  { return x.pos_; }
-func (x *Selector) typ() *Globals.Type  { return x.typ_; }
-
-
-func NewSelector(pos int, typ *Globals.Type) *Selector {
-	x := new(Selector);
-	x.pos_ = pos;
-	x.typ_ = typ;
-	return x;
-}
-
-
-// ----------------------------------------------------------------------------
-// Calls
-
-type Call struct {
-	recv, callee Globals.Expr;
-	args *Globals.List;
-}
-
-
-func (x *Call) op() int  { return CALL; }
-func (x *Call) pos() int  { return 0; }
-func (x *Call) typ() *Globals.Type  { return nil; }
-
-
-func NewCall(args *Globals.List) *Call {
-	x := new(Call);
-	x.args = args;
-	return x;
-}
-
-
-// ----------------------------------------------------------------------------
-// Binary expressions
-
-type BinaryExpr struct {
-	op_ int;
-	pos_ int;
-	typ_ *Globals.Type;
-	x, y Globals.Expr;
-}
-
-
-func (x *BinaryExpr) op() int  { return x.op_; }
-func (x *BinaryExpr) pos() int  { return x.pos_; }
-func (x *BinaryExpr) typ() *Globals.Type  {	return x.typ_; }
-
-
-// ----------------------------------------------------------------------------
-// Tuples
-
-type Tuple struct {
-	typ_ *Globals.Type;
-	list *Globals.List;
-}
-
-
-func (x *Tuple) op() int  {	return TUPLE; }
-func (x *Tuple) pos() int  { return x.list.first.expr.pos(); }
-func (x *Tuple) typ() *Globals.Type  { return x.typ_; }
-
-
-func NewTuple(list *Globals.List) *Tuple {
-	// make corresponding tuple type
-	scope := Globals.NewScope(nil);
-	for p := list.first; p != nil; p = p.next {
-		x := p.expr;
-		obj := Globals.NewObject(x.pos(), GlobalObject.FIELD, "");
-		obj.typ = x.typ();
-		scope.Add(obj);
-	}
-	typ := Globals.NewType(Type.TUPLE);
-	typ.scope = scope;
-
-	// create the tuple
-	x := new(Tuple);
-	x.typ_ = typ;
-	x.list = list;
-	return x;
-}
-
-
-// ----------------------------------------------------------------------------
-// Statements
-
-type Block struct {
-	// TODO fill in
-}
-
-
-type IfStat struct {
-	cond Globals.Expr;
-	then_ Globals.Stat;
-	else_ Globals.Stat;
-}
-
-
-// ----------------------------------------------------------------------------
-// Initialization
-
-func init() {
-	Bad = NewLiteral(-1, Universe.bad_t);
-	True = NewLiteral(-1, Universe.bool_t);  True.b = true;
-	False = NewLiteral(-1, Universe.bool_t);  False.b = false;
-	Nil = NewLiteral(-1, Universe.nil_t);
-}
diff --git a/usr/gri/gosrc/base.go b/usr/gri/gosrc/base.go
deleted file mode 100755
index 9620fbd..0000000
--- a/usr/gri/gosrc/base.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Base for the decls.go tests.
-
-package base
-
-type Foo int
-
-type Bar *float;
-
-type Node struct {
-  left, right *Node;
-  val bool;
-  f Foo;
-}
-
-func (p *Node) F(x int) {};
-
-type I interface {
-  f();
-}
diff --git a/usr/gri/gosrc/compilation.go b/usr/gri/gosrc/compilation.go
deleted file mode 100644
index bde2d69..0000000
--- a/usr/gri/gosrc/compilation.go
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Compilation
-
-import Platform "platform"
-import Utils "utils"
-import Globals "globals"
-import Object "object"
-import Type "type"
-import Universe "universe"
-import Scanner "scanner"
-import AST "ast"
-import Parser "parser"
-import Importer "import"
-import Exporter "export"
-import Printer "printer"
-import Verifier "verifier"
-
-
-// Compute (line, column) information for a given source position.
-func LineCol(src string, pos int) (line, col int) {
-	line = 1;
-	lpos := 0;
-
-	if pos > len(src) {
-		pos = len(src);
-	}
-
-	for i := 0; i < pos; i++ {
-		if src[i] == '\n' {
-			line++;
-			lpos = i;
-		}
-	}
-
-	return line, pos - lpos;
-}
-
-
-func Error(comp *Globals.Compilation, pos int, msg string) {
-	const errdist = 10;
-	delta := pos - comp.errpos;  // may be negative!
-	if delta < 0 {
-		delta = -delta;
-	}
-	if delta > errdist || comp.nerrors == 0 /* always report first error */ {
-		print(comp.src_file);
-		if pos >= 0 {
-			// print position
-			line, col := LineCol(comp.src, pos);
-			if Platform.USER == "gri" {
-				print(":", line, ":", col);
-			} else {
-				print(":", line);
-			}
-		}
-		print(": ", msg, "\n");
-		comp.nerrors++;
-		comp.errpos = pos;
-	}
-
-	if comp.nerrors >= 10 {
-		sys.Exit(1);
-	}
-}
-
-
-func ReadImport(comp* Globals.Compilation, filename string, update bool) (data string, ok bool) {
-	if filename == "" {
-		panic("illegal package file name");
-	}
-
-	// see if it just works
-	data, ok = Platform.ReadObjectFile(filename);
-	if ok {
-		return data, ok;
-	}
-
-	if filename[0] == '/' {
-		// absolute path
-		panic(`don't know how to handle absolute import file path "` + filename + `"`);
-	}
-
-	// relative path
-	// try relative to the $GOROOT/pkg directory
-	std_filename := Platform.GOROOT + "/pkg/" + filename;
-	data, ok = Platform.ReadObjectFile(std_filename);
-	if ok {
-		return data, ok;
-	}
-
-	if !update {
-		return "", false;
-	}
-
-	// TODO BIG HACK - fix this!
-	// look for a src file
-	// see if it just works
-	data, ok = Platform.ReadSourceFile(filename);
-	if ok {
-		comp.env.Compile(comp, filename + Platform.src_file_ext);
-		data, ok = ReadImport(comp, filename, false);
-		if ok {
-			return data, ok;
-		}
-	}
-
-	return "", false;
-}
-
-
-func Import(comp *Globals.Compilation, pkg_file string) *Globals.Package {
-	data, ok := ReadImport(comp, pkg_file, comp.flags.update_packages);
-	var pkg *Globals.Package;
-	if ok {
-		pkg = Importer.Import(comp, data);
-	}
-	return pkg;
-}
-
-
-func Export(comp *Globals.Compilation, pkg_file string) {
-	data := Exporter.Export(comp);
-	ok := Platform.WriteObjectFile(pkg_file, data);
-	if !ok {
-		panic("export failed");
-	}
-}
-
-
-func Compile(comp *Globals.Compilation, src_file string) {
-	// TODO This is incorrect: When compiling with the -r flag, we are
-	// calling this function recursively w/o setting up a new comp - this
-	// is broken and leads to an assertion error (more then one package
-	// upon parsing of the package header).
-
-	src, ok := Platform.ReadSourceFile(src_file);
-	if !ok {
-		print("cannot open ", src_file, "\n");
-		return;
-	}
-
-	comp.src_file = src_file;
-	comp.src = src;
-
-	if comp.flags.verbosity > 0 {
-		print(src_file, "\n");
-	}
-
-	scanner := new(Scanner.Scanner);
-	scanner.Open(src_file, src);
-
-	var tstream chan *Scanner.Token;
-	if comp.flags.token_chan {
-		tstream = make(chan *Scanner.Token, 100);
-		go scanner.Server(tstream);
-	}
-
-	parser := new(Parser.Parser);
-	parser.Open(comp, scanner, tstream);
-
-	parser.ParseProgram();
-	if parser.scanner.nerrors > 0 {
-		return;
-	}
-
-	Verifier.Verify(comp);
-
-	if comp.flags.print_interface {
-		Printer.PrintObject(comp, comp.pkg_list[0].obj, false);
-	}
-
-	Export(comp, src_file);
-}
diff --git a/usr/gri/gosrc/decls.go b/usr/gri/gosrc/decls.go
deleted file mode 100755
index 20216f8..0000000
--- a/usr/gri/gosrc/decls.go
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Tests.
-
-package decls
-
-import "base"
-import base2 "base"
-
-const c0 int = 0
-const c1 float = 1.
-const (
-	c2 byte = 2;
-	c3 int = 3;
-	c4 float = 4.;
-)
-
-
-type (
-	Node0 base.Node
-	Node1 *base2.Node
-)
-
-type T0 byte
-type T1 T0
-type (
-	T2 [10]T0;
-	T3 map [string] int;
-)
-type T4 struct {
-	f1, f2, f3 int;
-	f4 [] float;
-};
-type (
-	T5 *T4;
-)
-
-type F0 ()
-type F1 (a int)
-type F2 (a, b int, c float)
-type F3 () bool
-type F4 (a int) (z T5, ok bool)
-type F5 (a, b int, c float) (z T5, ok bool)
-type F6 (a int, b float) bool
-type F7 (a int, b float, c, d *bool) bool
-
-type T6 chan int
-type T7 <- chan *T6
-type T8 chan <- *T6
-
-type T9 struct {
-	p *T9;
-	q [] map [int] *T9;
-	f *(x, y *T9) *T9;
-}
-
-type T11 struct {
-	p *T10;
-}
-
-type T10 struct {
-	p *T11;
-}
-
-type T12 struct {
-	p *T12
-}
-
-type I0 interface {}
-type I1 interface {
-	Do0(q *I0);
-	Do1(p *I1) bool;
-}
-type I2 interface {
-	M0();
-	M1(a int);
-	M2(a, b int, c float);
-	M3() bool;
-	M4(a int) (z T5, ok bool);
-	M5(a, b int, c float) (z T5, ok bool);
-}
-
-
-var v0 int
-var v1 float = c1
-
-var (
-	v2 T2;
-	v3 struct {
-		f1, f2, f3 *M0;
-	}
-)
-
-
-func f0() {}
-func f1(a int) {}
-func f2(a, b int, c float) {}
-func f3() bool { return false; }
-func f4(a int) (z T5, ok bool) {}
-func f5(a, b int, c float) (z T5, ok bool) {
-	u, v := 0, 0;
-	return;
-}
-
-
-func (p *T4) m0() {}
-func (p *T4) m1(a int) {}
-func (p *T4) m2(a, b int, c float) {}
-func (p *T4) m3() bool { return false; }
-func (p *T4) m4(a int) (z T5, ok bool) { return; }
-func (p *T4) m5(a, b int, c float) (z T5, ok bool) {
-	L: var x = a;
-}
-
-
-func f2() {
-	type T *T14;
-}
-type T14 int;
diff --git a/usr/gri/gosrc/export.go b/usr/gri/gosrc/export.go
deleted file mode 100755
index 8f4f211..0000000
--- a/usr/gri/gosrc/export.go
+++ /dev/null
@@ -1,294 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Exporter
-
-import Platform "platform"
-import Utils "utils"
-import Globals "globals"
-import Object "object"
-import Type "type"
-import Universe "universe"
-
-
-type Exporter struct {
-	comp *Globals.Compilation;
-	debug bool;
-	buf [4*1024] byte;
-	buf_pos int;
-	pkg_ref int;
-	type_ref int;
-};
-
-
-func (E *Exporter) WriteObject(obj *Globals.Object);
-
-
-func (E *Exporter) WriteByte(x byte) {
-	E.buf[E.buf_pos] = x;
-	E.buf_pos++;
-	/*
-	if E.debug {
-		print(" ", x);
-	}
-	*/
-}
-
-
-func (E *Exporter) WriteInt(x int) {
-	x0 := x;
-	for x < -64 || x >= 64 {
-		E.WriteByte(byte(x & 127));
-		x = int(uint(x >> 7));  // arithmetic shift
-	}
-	// -64 <= x && x < 64
-	E.WriteByte(byte(x + 192));
-	/*
-	if E.debug {
-		print(" #", x0);
-	}
-	*/
-}
-
-
-func (E *Exporter) WriteString(s string) {
-	n := len(s);
-	E.WriteInt(n);
-	for i := 0; i < n; i++ {
-		E.WriteByte(s[i]);
-	}
-	if E.debug {
-		print(` "`, s, `"`);
-	}
-}
-
-
-func (E *Exporter) WritePackageTag(tag int) {
-	E.WriteInt(tag);
-	if E.debug {
-		if tag >= 0 {
-			print(" [P", tag, "]");  // package ref
-		} else {
-			print("\nP", E.pkg_ref, ":");
-		}
-	}
-}
-
-
-func (E *Exporter) WriteTypeTag(tag int) {
-	E.WriteInt(tag);
-	if E.debug {
-		if tag >= 0 {
-			print(" [T", tag, "]");  // type ref
-		} else {
-			print("\nT", E.type_ref, ": ", Type.FormStr(-tag));
-		}
-	}
-}
-
-
-func (E *Exporter) WriteObjectTag(tag int) {
-	if tag < 0 {
-		panic("tag < 0");
-	}
-	E.WriteInt(tag);
-	if E.debug {
-		print("\n", Object.KindStr(tag));
-	}
-}
-
-
-func (E *Exporter) WritePackage(pkg *Globals.Package) {
-	if E.comp.pkg_list[pkg.obj.pnolev] != pkg {
-		panic("inconsistent package object");
-	}
-
-	if pkg.ref >= 0 {
-		E.WritePackageTag(pkg.ref);  // package already exported
-		return;
-	}
-
-	E.WritePackageTag(-1);
-	pkg.ref = E.pkg_ref;
-	E.pkg_ref++;
-
-	E.WriteString(pkg.obj.ident);
-	E.WriteString(pkg.file_name);
-	E.WriteString(pkg.key);
-}
-
-
-func (E *Exporter) WriteScope(scope *Globals.Scope) {
-	if E.debug {
-		print(" {");
-	}
-
-	for p := scope.entries.first; p != nil; p = p.next {
-		if p.obj.exported {
-			E.WriteObject(p.obj);
-		}
-	}
-	E.WriteObject(nil);
-
-	if E.debug {
-		print(" }");
-	}
-}
-
-
-func (E *Exporter) WriteType(typ *Globals.Type) {
-	if typ.ref >= 0 {
-		E.WriteTypeTag(typ.ref);  // type already exported
-		return;
-	}
-
-	if -typ.form >= 0 {
-		panic("conflict with ref numbers");
-	}
-	E.WriteTypeTag(-typ.form);
-	typ.ref = E.type_ref;
-	E.type_ref++;
-
-	// if we have a named type, export the type identifier and package
-	ident := "";
-	if typ.obj != nil {
-		// named type
-		if typ.obj.typ != typ {
-			panic("inconsistent named type");
-		}
-		ident = typ.obj.ident;
-		if !typ.obj.exported {
-			// the type is invisible (it's identifier is not exported)
-			// prepend "." to the identifier to make it an illegal
-			// identifier for importing packages and thus inaccessible
-			// from those package's source code
-			ident = "." + ident;
-		}
-	}
-
-	E.WriteString(ident);
-	if len(ident) > 0 {
-		// named type
-		E.WritePackage(E.comp.pkg_list[typ.obj.pnolev]);
-	}
-
-	switch typ.form {
-	case Type.VOID:
-		// for now until we have enough of the front-end working.
-
-	case Type.FORWARD:
-		// corresponding package must be forward-declared too
-		if typ.obj == nil || E.comp.pkg_list[typ.obj.pnolev].key != "" {
-			panic("inconsistency in package.type forward declaration");
-		}
-
-	case Type.ALIAS, Type.MAP:
-		E.WriteType(typ.key);
-		E.WriteType(typ.elt);
-
-	case Type.TUPLE:
-		E.WriteType(typ.elt);
-
-	case Type.ARRAY:
-		E.WriteInt(typ.len);
-		E.WriteType(typ.elt);
-
-	case Type.CHANNEL:
-		E.WriteInt(typ.aux);
-		E.WriteType(typ.elt);
-
-	case Type.FUNCTION, Type.METHOD:
-		E.WriteInt(typ.len);
-		E.WriteType(typ.elt);
-		E.WriteScope(typ.scope);
-
-	case Type.STRUCT, Type.INTERFACE:
-		E.WriteScope(typ.scope);
-
-	case Type.POINTER:
-		E.WriteType(typ.elt);
-
-	default:
-		panic("UNREACHABLE");
-	}
-}
-
-
-func (E *Exporter) WriteObject(obj *Globals.Object) {
-	if obj == nil {
-		E.WriteObjectTag(Object.END);
-		return;
-	}
-	E.WriteObjectTag(obj.kind);
-
-	if obj.kind == Object.TYPE {
-		// named types are handled entirely by WriteType()
-		if obj.typ.obj != obj {
-			panic("inconsistent named type");
-		}
-		E.WriteType(obj.typ);
-		return;
-	}
-
-	E.WriteString(obj.ident);
-	E.WriteType(obj.typ);
-
-	switch obj.kind {
-	case Object.CONST:
-		E.WriteInt(0);  // should be the correct value
-
-	case Object.VAR, Object.FIELD:
-		E.WriteInt(0);  // should be the correct address/offset
-
-	case Object.FUNC:
-		E.WriteInt(0);  // should be the correct address/offset
-
-	default:
-		panic("UNREACHABLE");
-	}
-}
-
-
-func (E *Exporter) Export(comp* Globals.Compilation) string {
-	E.comp = comp;
-	E.debug = comp.flags.debug;
-	E.buf_pos = 0;
-	E.pkg_ref = 0;
-	E.type_ref = 0;
-
-	// write magic bits
-	magic := Platform.MAGIC_obj_file;  // TODO remove once len(constant) works
-	for i := 0; i < len(magic); i++ {
-		E.WriteByte(magic[i]);
-	}
-
-	// Predeclared types are "pre-exported".
-	// TODO run the loop below only in debug mode
-	{	i := 0;
-		for p := Universe.types.first; p != nil; p = p.next {
-			if p.typ.ref != i {
-				panic("incorrect ref for predeclared type");
-			}
-			i++;
-		}
-	}
-	E.type_ref = Universe.types.len;
-
-	// export package 0
-	pkg := comp.pkg_list[0];
-	E.WritePackage(pkg);
-	E.WriteScope(pkg.scope);
-
-	if E.debug {
-		print("\n(", E.buf_pos, " bytes)\n");
-	}
-
-	return string(E.buf)[0 : E.buf_pos];
-}
-
-
-func Export(comp* Globals.Compilation) string {
-	var E Exporter;
-	return (&E).Export(comp);
-}
diff --git a/usr/gri/gosrc/expr.go b/usr/gri/gosrc/expr.go
deleted file mode 100755
index 48681f6..0000000
--- a/usr/gri/gosrc/expr.go
+++ /dev/null
@@ -1,164 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Expr
-
-import Globals "globals"
-import Universe "universe"
-import Object "object"
-import Type "type"
-import AST "ast"
-
-
-// TODO the following shortcuts below don't work due to 6g/6l bugs
-//type Compilation Globals.Compilation
-//type Expr Globals.Expr
-
-
-func Error(comp *Globals.Compilation, pos int, msg string) {
-	comp.env.Error(comp, pos, msg);
-}
-
-
-func Deref(comp *Globals.Compilation, x Globals.Expr) Globals.Expr {
-	switch typ := x.typ(); typ.form {
-	case Type.BAD:
-		// ignore
-
-	case Type.POINTER:
-		x = AST.NewDeref(x);
-
-	default:
-		Error(comp, x.pos(), `"*" not applicable (typ.form = ` + Type.FormStr(typ.form) + `)`);
-		x = AST.Bad;
-	}
-
-	return x;
-}
-
-
-func Select(comp *Globals.Compilation, x Globals.Expr, pos int, selector string) Globals.Expr {
-	if x.typ().form == Type.POINTER {
-		x = Deref(comp, x);
-	}
-
-	switch typ := x.typ(); typ.form {
-	case Type.BAD:
-		// ignore
-
-	case Type.STRUCT, Type.INTERFACE:
-		obj := typ.scope.Lookup(selector);
-		if obj != nil {
-			x = AST.NewSelector(x.pos(), obj.typ);
-
-		} else {
-			Error(comp, pos, `no field/method "` + selector + `"`);
-			x = AST.Bad;
-		}
-
-	default:
-		Error(comp, pos, `"." not applicable (typ.form = ` + Type.FormStr(typ.form) + `)`);
-		x = AST.Bad;
-	}
-
-	return x;
-}
-
-
-func AssertType(comp *Globals.Compilation, x Globals.Expr, pos int, typ *Globals.Type) Globals.Expr {
-	return AST.Bad;
-}
-
-
-func Index(comp *Globals.Compilation, x, i Globals.Expr) Globals.Expr {
-	if x.typ().form == Type.POINTER {
-		x = Deref(comp, x);
-	}
-
-	switch typ := x.typ(); typ.form {
-	case Type.BAD:
-		// ignore
-
-	case Type.STRING, Type.ARRAY:
-		x = AST.Bad;
-
-	case Type.MAP:
-		if Type.Equal(typ.key, i.typ()) {
-			// x = AST.NewSubscript(x, i1);
-			x = AST.Bad;
-
-		} else {
-			Error(comp, x.pos(), "map key type mismatch");
-			x = AST.Bad;
-		}
-
-	default:
-		Error(comp, x.pos(), `"[]" not applicable (typ.form = ` + Type.FormStr(typ.form) + `)`);
-		x = AST.Bad;
-	}
-	return x;
-}
-
-
-func Slice(comp *Globals.Compilation, x, i, j Globals.Expr) Globals.Expr {
-	if x.typ().form == Type.POINTER {
-		x = Deref(comp, x);
-	}
-
-	switch typ := x.typ(); typ.form {
-	case Type.BAD:
-		// ignore
-		break;
-	case Type.STRING, Type.ARRAY:
-		x = AST.Bad;
-
-	case Type.MAP:
-		if Type.Equal(typ.key, i.typ()) {
-			// x = AST.NewSubscript(x, i1);
-			x = AST.Bad;
-
-		} else {
-			Error(comp, x.pos(), "map key type mismatch");
-			x = AST.Bad;
-		}
-
-	default:
-		Error(comp, x.pos(), `"[:]" not applicable (typ.form = ` + Type.FormStr(typ.form) + `)`);
-		x = AST.Bad;
-	}
-	return x;
-}
-
-
-func Call(comp *Globals.Compilation, x Globals.Expr, args *Globals.List) Globals.Expr {
-	if x.typ().form == Type.POINTER {
-		x = Deref(comp, x);
-	}
-
-	if x.op() == AST.OBJECT && x.(*AST.Object).obj.kind == Object.BUILTIN {
-		panic("builtin call - UNIMPLEMENTED");
-	}
-
-	typ := x.typ();
-	if typ.form == Type.FUNCTION || typ.form == Type.METHOD {
-		// TODO check args against parameters
-	}
-
-	return AST.Bad;
-}
-
-
-func UnaryExpr(comp *Globals.Compilation, x Globals.Expr) Globals.Expr {
-	return AST.Bad;
-}
-
-
-func BinaryExpr(comp *Globals.Compilation, x, y Globals.Expr) Globals.Expr {
-	e := new(AST.BinaryExpr);
-	e.typ_ = x.typ();  // TODO fix this
-	//e.op = P.tok;  // TODO should we use tokens or separate operator constants?
-	e.x = x;
-	e.y = y;
-	return e;
-}
diff --git a/usr/gri/gosrc/globals.go b/usr/gri/gosrc/globals.go
deleted file mode 100644
index 7b2fb9c..0000000
--- a/usr/gri/gosrc/globals.go
+++ /dev/null
@@ -1,350 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Globals
-
-
-// The following types should really be in their respective files
-// (object.go, type.go, scope.go, package.go, compilation.go, etc.) but
-// they refer to each other and we don't know how to handle forward
-// declared pointers across packages yet.
-
-
-// ----------------------------------------------------------------------------
-
-type Type struct
-type Scope struct
-type Elem struct
-type Compilation struct
-
-// Object represents a language object, such as a constant, variable, type,
-// etc. (kind). An objects is (pre-)declared at a particular position in the
-// source code (pos), has a name (ident), a type (typ), and a package number
-// or nesting level (pnolev).
-
-type Object struct {
-	exported bool;
-	pos int;  // source position (< 0 if unknown position)
-	kind int;
-	ident string;
-	typ *Type;  // nil for packages
-	pnolev int;  // >= 0: package no., <= 0: function nesting level, 0: global level
-}
-
-
-type Type struct {
-	ref int;  // for exporting only: >= 0 means already exported
-	form int;
-	size int;  // in bytes
-	len int;  // array length, no. of function/method parameters (w/o recv)
-	aux int;  // channel info
-	obj *Object;  // primary type object or NULL
-	key *Type;  // alias base type or map key
-	elt *Type;  // aliased type, array, map, channel or pointer element type, function result type, tuple function type
-	scope *Scope;  // forwards, structs, interfaces, functions
-}
-
-
-type Package struct {
-	ref int;  // for exporting only: >= 0 means already exported
-	file_name string;
-	key string;
-	obj *Object;
-	scope *Scope;  // holds the (global) objects in this package
-}
-
-
-type List struct {
-	len int;
-	first, last *Elem;
-};
-
-
-type Scope struct {
-	parent *Scope;
-	entries *List;
-	// entries map[string] *Object;  // doesn't work properly
-}
-
-
-type Flags struct {
-	debug bool;
-	object_file string;
-	update_packages bool;
-	print_interface bool;
-	verbosity uint;
-	sixg bool;
-	token_chan bool;
-}
-
-
-type Environment struct {
-	Error *(comp *Compilation, pos int, msg string);
-	Import *(comp *Compilation, pkg_file string) *Package;
-	Export *(comp *Compilation, pkg_file string);
-	Compile *(comp *Compilation, src_file string);
-}
-
-
-type Compilation struct {
-	// environment
-	flags *Flags;
-	env *Environment;
-
-	// TODO rethink the need for this here
-	src_file string;
-	src string;
-
-	// Error handling
-	nerrors int;  // number of errors reported
-	errpos int;  // last error position
-
-	// TODO use open arrays eventually
-	pkg_list [256] *Package;  // pkg_list[0] is the current package
-	pkg_ref int;
-}
-
-
-type Expr interface {
-	op() int;  // node operation
-	pos() int;  // source position
-	typ() *Type;
-	// ... more to come here
-}
-
-
-type Stat interface {
-	// ... more to come here
-}
-
-
-// TODO This is hideous! We need to have a decent way to do lists.
-// Ideally open arrays that allow '+'.
-
-type Elem struct {
-	next *Elem;
-	val int;
-	str string;
-	obj *Object;
-	typ *Type;
-	expr Expr
-}
-
-
-// ----------------------------------------------------------------------------
-// Creation
-
-var Universe_void_t *Type  // initialized by Universe to Universe.void_t
-
-func NewObject(pos, kind int, ident string) *Object {
-	obj := new(Object);
-	obj.exported = false;
-	obj.pos = pos;
-	obj.kind = kind;
-	obj.ident = ident;
-	obj.typ = Universe_void_t;
-	obj.pnolev = 0;
-	return obj;
-}
-
-
-func NewType(form int) *Type {
-	typ := new(Type);
-	typ.ref = -1;  // not yet exported
-	typ.form = form;
-	return typ;
-}
-
-
-func NewPackage(file_name string, obj *Object, scope *Scope) *Package {
-	pkg := new(Package);
-	pkg.ref = -1;  // not yet exported
-	pkg.file_name = file_name;
-	pkg.key = "<the package key>";  // empty key means package forward declaration
-	pkg.obj = obj;
-	pkg.scope = scope;
-	return pkg;
-}
-
-
-func NewList() *List {
-	return new(List);
-}
-
-
-func NewScope(parent *Scope) *Scope {
-	scope := new(Scope);
-	scope.parent = parent;
-	scope.entries = NewList();
-	return scope;
-}
-
-
-// ----------------------------------------------------------------------------
-// Object methods
-
-func (obj *Object) Copy() *Object {
-	copy := new(Object);
-	copy.exported = obj.exported;
-	copy.pos = obj.pos;
-	copy.kind = obj.kind;
-	copy.ident = obj.ident;
-	copy.typ = obj.typ;
-	copy.pnolev = obj.pnolev;
-	return copy;
-}
-
-
-// ----------------------------------------------------------------------------
-// List methods
-
-func (L *List) at(i int) *Elem {
-	if i < 0 || L.len <= i {
-		panic("index out of bounds");
-	}
-
-	p := L.first;
-	for ; i > 0; i-- {
-		p = p.next;
-	}
-
-	return p;
-}
-
-
-func (L *List) Clear() {
-	L.len, L.first, L.last = 0, nil, nil;
-}
-
-
-func (L *List) Add() *Elem {
-	L.len++;
-	e := new(Elem);
-	if L.first == nil {
-		L.first = e;
-	} else {
-		L.last.next = e;
-	}
-	L.last = e;
-	return e;
-}
-
-
-func (L *List) IntAt(i int) int {
-	return L.at(i).val;
-}
-
-
-func (L *List) StrAt(i int) string {
-	return L.at(i).str;
-}
-
-
-func (L *List) ObjAt(i int) *Object {
-	return L.at(i).obj;
-}
-
-
-func (L *List) TypAt(i int) *Type {
-	return L.at(i).typ;
-}
-
-
-func (L *List) ExprAt(i int) Expr {
-	return L.at(i).expr;
-}
-
-
-func (L *List) AddInt(val int) {
-	L.Add().val = val;
-}
-
-
-func (L *List) AddStr(str string) {
-	L.Add().str = str;
-}
-
-
-func (L *List) AddObj(obj *Object) {
-	L.Add().obj = obj;
-}
-
-
-func (L *List) AddTyp(typ *Type) {
-	L.Add().typ = typ;
-}
-
-
-func (L *List) AddExpr(expr Expr) {
-	L.Add().expr = expr;
-}
-
-
-// ----------------------------------------------------------------------------
-// Scope methods
-
-func (scope *Scope) Lookup(ident string) *Object {
-	for p := scope.entries.first; p != nil; p = p.next {
-		if p.obj.ident == ident {
-			return p.obj;
-		}
-	}
-	return nil;
-}
-
-
-func (scope *Scope) Add(obj* Object) {
-	scope.entries.AddObj(obj);
-}
-
-
-func (scope *Scope) Insert(obj *Object) {
-	if scope.Lookup(obj.ident) != nil {
-		panic("obj already inserted");
-	}
-	scope.Add(obj);
-}
-
-
-func (scope *Scope) InsertImport(obj *Object) *Object {
-	 p := scope.Lookup(obj.ident);
-	 if p == nil {
-		scope.Add(obj);
-		p = obj;
-	 }
-	 return p;
-}
-
-
-func (scope *Scope) Print() {
-	print("scope {");
-	for p := scope.entries.first; p != nil; p = p.next {
-		print("\n  ", p.obj.ident);
-	}
-	print("\n}\n");
-}
-
-
-// ----------------------------------------------------------------------------
-// Compilation methods
-
-func (C *Compilation) Lookup(file_name string) *Package {
-	for i := 0; i < C.pkg_ref; i++ {
-		pkg := C.pkg_list[i];
-		if pkg.file_name == file_name {
-			return pkg;
-		}
-	}
-	return nil;
-}
-
-
-func (C *Compilation) Insert(pkg *Package) {
-	if C.Lookup(pkg.file_name) != nil {
-		panic("package already inserted");
-	}
-	pkg.obj.pnolev = C.pkg_ref;
-	C.pkg_list[C.pkg_ref] = pkg;
-	C.pkg_ref++;
-}
diff --git a/usr/gri/gosrc/go.go b/usr/gri/gosrc/go.go
deleted file mode 100644
index b56dc8b..0000000
--- a/usr/gri/gosrc/go.go
+++ /dev/null
@@ -1,91 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import Build "build"
-import Globals "globals"
-import Compilation "compilation"
-
-
-func PrintHelp() {
-	print(
-		"go (" + Build.time + ")\n" +
-		"usage:\n" +
-		"  go { flag } { file }\n" +
-		"  -d             debug mode, additional self tests and prints\n" +
-		"  -o file        explicit object file\n" +
-		"  -r             recursively update imported packages in current directory\n" +
-		"  -p             print package interface\n" +
-		"  -v [0 .. 3]    verbosity level\n" +
-		"  -6g            6g compatibility mode\n" +
-		"  -token_chan    use token channel to scan and parse in parallel\n"
-	);
-}
-
-
-var argno int = 1;
-func Next() string {
-	arg := "";
-	if argno < len(sys.Args) {
-		arg = sys.Args[argno];
-		argno++;
-	}
-	return arg;
-}
-
-
-func main() {
-	arg := Next();
-
-	if arg == "" {
-		PrintHelp();
-		return;
-	}
-
-	// collect flags and files
-	flags := new(Globals.Flags);
-	files := Globals.NewList();
-	for arg != "" {
-	    switch arg {
-		case "-d": flags.debug = true;
-		case "-o": flags.object_file = Next();
-			print("note: -o flag ignored at the moment\n");
-		case "-r": flags.update_packages = true;
-		case "-p": flags.print_interface = true;
-		case "-v":
-			arg = Next();
-			switch arg {
-			case "0", "1", "2", "3":
-				flags.verbosity = uint(arg[0] - '0');
-			default:
-				// anything else is considered the next argument
-				flags.verbosity = 1;
-				continue;
-			}
-		case "-6g": flags.sixg = true;
-		case "-token_chan": flags.token_chan = true;
-		default: files.AddStr(arg);
-		}
-		arg = Next();
-	}
-
-	// setup environment
-	env := new(Globals.Environment);
-	env.Error = &Compilation.Error;
-	env.Import = &Compilation.Import;
-	env.Export = &Compilation.Export;
-	env.Compile = &Compilation.Compile;
-
-	// compile files
-	for p := files.first; p != nil; p = p.next {
-		// setup compilation
-		comp := new(Globals.Compilation);
-		comp.flags = flags;
-		comp.env = env;
-
-		// compile
-		Compilation.Compile(comp, p.str);
-	}
-}
diff --git a/usr/gri/gosrc/import.go b/usr/gri/gosrc/import.go
deleted file mode 100755
index d86d6ef..0000000
--- a/usr/gri/gosrc/import.go
+++ /dev/null
@@ -1,323 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Importer
-
-import Platform "platform"
-import Utils "utils"
-import Globals "globals"
-import Object "object"
-import Type "type"
-import Universe "universe"
-
-
-type Importer struct {
-	comp *Globals.Compilation;
-	debug bool;
-	buf string;
-	buf_pos int;
-	pkg_list [256] *Globals.Package;
-	pkg_ref int;
-	type_list [1024] *Globals.Type;
-	type_ref int;
-};
-
-
-func (I *Importer) ReadObject() *Globals.Object;
-
-
-func (I *Importer) ReadByte() byte {
-	x := I.buf[I.buf_pos];
-	I.buf_pos++;
-	/*
-	if E.debug {
-		print(" ", x);
-	}
-	*/
-	return x;
-}
-
-
-func (I *Importer) ReadInt() int {
-	x := 0;
-	s := uint(0);
-	b := I.ReadByte();
-	for b < 128 {
-		x |= int(b) << s;
-		s += 7;
-		b = I.ReadByte();
-	}
-	// b >= 128
-	x |= ((int(b) - 192) << s);
-	/*
-	if I.debug {
-		print(" #", x);
-	}
-	*/
-	return x;
-}
-
-
-func (I *Importer) ReadString() string {
-	var buf [256] byte;  // TODO this needs to be fixed
-	n := I.ReadInt();
-	for i := 0; i < n; i++ {
-		buf[i] = I.ReadByte();
-	}
-	s := string(buf)[0 : n];
-	if I.debug {
-		print(` "`, s, `"`);
-	}
-	return s;
-}
-
-
-func (I *Importer) ReadPackageTag() int {
-	tag := I.ReadInt();
-	if I.debug {
-		if tag >= 0 {
-			print(" [P", tag, "]");  // package ref
-		} else {
-			print("\nP", I.pkg_ref, ":");
-		}
-	}
-	return tag;
-}
-
-
-func (I *Importer) ReadTypeTag() int {
-	tag := I.ReadInt();
-	if I.debug {
-		if tag >= 0 {
-			print(" [T", tag, "]");  // type ref
-		} else {
-			print("\nT", I.type_ref, ": ", Type.FormStr(-tag));
-		}
-	}
-	return tag;
-}
-
-
-func (I *Importer) ReadObjectTag() int {
-	tag := I.ReadInt();
-	if tag < 0 {
-		panic("tag < 0");
-	}
-	if I.debug {
-		print("\n", Object.KindStr(tag));
-	}
-	return tag;
-}
-
-
-func (I *Importer) ReadPackage() *Globals.Package {
-	tag := I.ReadPackageTag();
-	if tag >= 0 {
-		return I.pkg_list[tag];  // package already imported
-	}
-
-	ident := I.ReadString();
-	file_name := I.ReadString();
-	key := I.ReadString();
-
-	// Canonicalize package - if it was imported before,
-	// use the primary import.
-	pkg := I.comp.Lookup(file_name);
-	if pkg == nil {
-		// new package
-		obj := Globals.NewObject(-1, Object.PACKAGE, ident);
-		pkg = Globals.NewPackage(file_name, obj, Globals.NewScope(nil));
-		I.comp.Insert(pkg);
-		if I.comp.flags.verbosity > 1 {
-			print(`import: implicitly adding package `, ident, ` "`, file_name, `" (pno = `, obj.pnolev, ")\n");
-		}
-	} else if key != "" && key != pkg.key {
-		// the package was imported before but the package
-		// key has changed (a "" key indicates a forward-
-		// declared package - it's key is consistent with
-		// any actual package of the same name)
-		panic("package key inconsistency");
-	}
-	I.pkg_list[I.pkg_ref] = pkg;
-	I.pkg_ref++;
-
-	return pkg;
-}
-
-
-func (I *Importer) ReadScope(scope *Globals.Scope, allow_multiples bool) {
-	if I.debug {
-		print(" {");
-	}
-
-	obj := I.ReadObject();
-	for obj != nil {
-		// allow_multiples is for debugging only - we should never
-		// have multiple imports where we don't expect them
-		if allow_multiples {
-			scope.InsertImport(obj);
-		} else {
-			scope.Insert(obj);
-		}
-		obj = I.ReadObject();
-	}
-
-	if I.debug {
-		print(" }");
-	}
-}
-
-
-func (I *Importer) ReadType() *Globals.Type {
-	tag := I.ReadTypeTag();
-	if tag >= 0 {
-		return I.type_list[tag];  // type already imported
-	}
-
-	typ := Globals.NewType(-tag);
-	ptyp := typ;  // primary type
-
-	ident := I.ReadString();
-	if len(ident) > 0 {
-		// named type
-		pkg := I.ReadPackage();
-
-		// create corresponding type object
-		obj := Globals.NewObject(0, Object.TYPE, ident);
-		obj.exported = true;
-		obj.typ = typ;
-		obj.pnolev = pkg.obj.pnolev;
-		typ.obj = obj;
-
-		// canonicalize type
-		// (if the type was seen before, use primary instance!)
-		ptyp = pkg.scope.InsertImport(obj).typ;
-	}
-	// insert the primary type into the type table but
-	// keep filling in the current type fields
-	I.type_list[I.type_ref] = ptyp;
-	I.type_ref++;
-
-	switch (typ.form) {
-	case Type.VOID:
-		// for now until we have enough of the front-end working
-		// change the form to BAD to avoid error messages
-		typ.form = Type.BAD;
-
-	case Type.FORWARD:
-		typ.scope = Globals.NewScope(nil);
-
-	case Type.TUPLE:
-		typ.elt = I.ReadType();
-
-	case Type.ALIAS, Type.MAP:
-		typ.key = I.ReadType();
-		typ.elt = I.ReadType();
-
-	case Type.ARRAY:
-		typ.len = I.ReadInt();
-		typ.elt = I.ReadType();
-
-	case Type.CHANNEL:
-		typ.aux = I.ReadInt();
-		typ.elt = I.ReadType();
-
-	case Type.FUNCTION, Type.METHOD:
-		typ.len = I.ReadInt();
-		typ.elt = I.ReadType();
-		typ.scope = Globals.NewScope(nil);
-		I.ReadScope(typ.scope, false);
-
-	case Type.STRUCT, Type.INTERFACE:
-		typ.scope = Globals.NewScope(nil);
-		I.ReadScope(typ.scope, false);
-
-	case Type.POINTER:
-		typ.elt = I.ReadType();
-
-	default:
-		panic("UNREACHABLE");
-	}
-
-	return ptyp;  // only use primary type
-}
-
-
-func (I *Importer) ReadObject() *Globals.Object {
-	tag := I.ReadObjectTag();
-	if tag == Object.END {
-		return nil;
-	}
-
-	if tag == Object.TYPE {
-		// named types are handled entirely by ReadType()
-		typ := I.ReadType();
-		if typ.obj.typ != typ {
-			panic("inconsistent named type");
-		}
-		return typ.obj;
-	}
-
-	ident := I.ReadString();
-	obj := Globals.NewObject(0, tag, ident);
-	obj.exported = true;
-	obj.typ = I.ReadType();
-
-	switch (tag) {
-	case Object.CONST:
-		I.ReadInt();  // should set the value field
-
-	case Object.VAR, Object.FIELD:
-		I.ReadInt();  // should set the address/offset field
-
-	case Object.FUNC:
-		I.ReadInt();  // should set the address/offset field
-
-	default:
-		panic("UNREACHABLE");
-	}
-
-	return obj;
-}
-
-
-func (I *Importer) Import(comp* Globals.Compilation, data string) *Globals.Package {
-	I.comp = comp;
-	I.debug = comp.flags.debug;
-	I.buf = data;
-	I.buf_pos = 0;
-	I.pkg_ref = 0;
-	I.type_ref = 0;
-
-	// check magic bits
-	if !Utils.Contains(data, Platform.MAGIC_obj_file, 0) {
-		return nil;
-	}
-
-	// Predeclared types are "pre-imported".
-	for p := Universe.types.first; p != nil; p = p.next {
-		if p.typ.ref != I.type_ref {
-			panic("incorrect ref for predeclared type");
-		}
-		I.type_list[I.type_ref] = p.typ;
-		I.type_ref++;
-	}
-
-	// import package
-	pkg := I.ReadPackage();
-	I.ReadScope(pkg.scope, true);
-
-	if I.debug {
-		print("\n(", I.buf_pos, " bytes)\n");
-	}
-
-	return pkg;
-}
-
-
-func Import(comp *Globals.Compilation, data string) *Globals.Package {
-	var I Importer;
-	pkg := (&I).Import(comp, data);
-	return pkg;
-}
diff --git a/usr/gri/gosrc/object.go b/usr/gri/gosrc/object.go
deleted file mode 100755
index 7187960..0000000
--- a/usr/gri/gosrc/object.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Object
-
-import Globals "globals"
-
-
-const /* kind */ (
-	BAD = iota;  // error handling
-	CONST; TYPE; VAR; FIELD; FUNC; BUILTIN; PACKAGE; LABEL;
-	END;  // end of scope (import/export only)
-)
-
-
-// The 'Object' declaration should be here as well, but 6g cannot handle
-// this due to cross-package circular references. For now it's all in
-// globals.go.
-
-
-func KindStr(kind int) string {
-	switch kind {
-	case BAD: return "BAD";
-	case CONST: return "CONST";
-	case TYPE: return "TYPE";
-	case VAR: return "VAR";
-	case FIELD: return "FIELD";
-	case FUNC: return "FUNC";
-	case BUILTIN: return "BUILTIN";
-	case PACKAGE: return "PACKAGE";
-	case LABEL: return "LABEL";
-	case END: return "END";
-	}
-	return "<unknown Object kind>";
-}
diff --git a/usr/gri/gosrc/parser.go b/usr/gri/gosrc/parser.go
deleted file mode 100644
index a606431..0000000
--- a/usr/gri/gosrc/parser.go
+++ /dev/null
@@ -1,2041 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Parser
-
-import Utils "utils"
-import Scanner "scanner"
-import Globals "globals"
-import Object "object"
-import Type "type"
-import Universe "universe"
-import Import "import"
-import AST "ast"
-import Expr "expr"
-
-
-type Parser struct {
-	comp *Globals.Compilation;
-	verbose bool;
-	indent uint;
-	scanner *Scanner.Scanner;
-	tokchan chan *Scanner.Token;
-
-	// Token
-	tok int;  // one token look-ahead
-	pos int;  // token source position
-	val string;  // token value (for IDENT, NUMBER, STRING only)
-
-	// Semantic analysis
-	level int;  // 0 = global scope, -1 = function/struct scope of global functions/structs, etc.
-	top_scope *Globals.Scope;
-	forward_types *Globals.List;
-	exports *Globals.List;
-}
-
-
-// ----------------------------------------------------------------------------
-// Support functions
-
-func (P *Parser) PrintIndent() {
-	for i := P.indent; i > 0; i-- {
-		print(". ");
-	}
-}
-
-
-func (P *Parser) Trace(msg string) {
-	if P.verbose {
-		P.PrintIndent();
-		print(msg, " {\n");
-	}
-	P.indent++;  // always, so proper identation is always checked
-}
-
-
-func (P *Parser) Ecart() {
-	P.indent--;  // always, so proper identation is always checked
-	if P.verbose {
-		P.PrintIndent();
-		print("}\n");
-	}
-}
-
-
-func (P *Parser) Next() {
-	if P.tokchan == nil {
-		P.tok, P.pos, P.val = P.scanner.Scan();
-	} else {
-		t := <- P.tokchan;
-		P.tok, P.pos, P.val = t.tok, t.pos, t.val;
-	}
-	if P.verbose {
-		P.PrintIndent();
-		print("[", P.pos, "] ", Scanner.TokenName(P.tok), "\n");
-	}
-}
-
-
-func (P *Parser) Open(comp *Globals.Compilation, scanner *Scanner.Scanner, tokchan chan *Scanner.Token) {
-	P.comp = comp;
-	P.verbose = comp.flags.verbosity > 2;
-	P.indent = 0;
-	P.scanner = scanner;
-	P.tokchan = tokchan;
-	P.Next();
-	P.level = 0;
-	P.top_scope = Universe.scope;
-	P.forward_types = Globals.NewList();
-	P.exports = Globals.NewList();
-}
-
-
-func (P *Parser) Error(pos int, msg string) {
-	P.scanner.Error(pos, msg);
-}
-
-
-func (P *Parser) Expect(tok int) {
-	if P.tok != tok {
-		P.Error(P.pos, "expected '" + Scanner.TokenName(tok) + "', found '" + Scanner.TokenName(P.tok) + "'");
-	}
-	P.Next();  // make progress in any case
-}
-
-
-func (P *Parser) Optional(tok int) {
-	if P.tok == tok {
-		P.Next();
-	}
-}
-
-
-// ----------------------------------------------------------------------------
-// Scopes
-
-func (P *Parser) OpenScope() {
-	P.top_scope = Globals.NewScope(P.top_scope);
-}
-
-
-func (P *Parser) CloseScope() {
-	P.top_scope = P.top_scope.parent;
-}
-
-
-func (P *Parser) Lookup(ident string) *Globals.Object {
-	for scope := P.top_scope; scope != nil; scope = scope.parent {
-		obj := scope.Lookup(ident);
-		if obj != nil {
-			return obj;
-		}
-	}
-	return nil;
-}
-
-
-func (P *Parser) DeclareInScope(scope *Globals.Scope, obj *Globals.Object) {
-	if P.level > 0 {
-		panic("cannot declare objects in other packages");
-	}
-	obj.pnolev = P.level;
-	if scope.Lookup(obj.ident) != nil {
-		P.Error(obj.pos, `"` + obj.ident + `" is declared already`);
-		return;  // don't insert it into the scope
-	}
-	scope.Insert(obj);
-}
-
-
-func (P *Parser) Declare(obj *Globals.Object) {
-	P.DeclareInScope(P.top_scope, obj);
-}
-
-
-func MakeFunctionType(sig *Globals.Scope, p0, r0 int) *Globals.Type {
-	form := Type.FUNCTION;
-	if p0 == 1 {
-		form = Type.METHOD;
-	} else {
-		if p0 != 0 {
-			panic("incorrect p0");
-		}
-	}
-	typ := Globals.NewType(form);
-	typ.len = r0 - p0;
-	typ.scope = sig;
-
-	// set result type
-	if sig.entries.len - r0 == 1 {
-		// exactly one result value
-		typ.elt = sig.entries.last.obj.typ;
-	} else {
-		// 0 or >1 result values - create a tuple referring to this type
-		tup := Globals.NewType(Type.TUPLE);
-		tup.elt = typ;
-		typ.elt = tup;
-	}
-
-	// parameters/results are always exported (they can't be accessed
-	// w/o the function or function type being exported)
-	for p := sig.entries.first; p != nil; p = p.next {
-		p.obj.exported = true;
-	}
-
-	return typ;
-}
-
-
-func (P *Parser) DeclareFunc(pos int, ident string, typ *Globals.Type) *Globals.Object {
-	// determine scope
-	scope := P.top_scope;
-	if typ.form == Type.METHOD {
-		// declare in corresponding struct
-		if typ.scope.entries.len < 1 {
-			panic("no recv in signature?");
-		}
-		recv_typ := typ.scope.entries.first.obj.typ;
-		if recv_typ.form == Type.POINTER {
-			recv_typ = recv_typ.elt;
-		}
-		scope = recv_typ.scope;
-	}
-
-	// declare the function
-	obj := scope.Lookup(ident);
-	if obj == nil {
-		obj = Globals.NewObject(pos, Object.FUNC, ident);
-		obj.typ = typ;
-		// TODO do we need to set the primary type? probably...
-		P.DeclareInScope(scope, obj);
-		return obj;
-	}
-
-	// obj != NULL: possibly a forward declaration
-	if obj.kind != Object.FUNC {
-		P.Error(pos, `"` + ident + `" is declared already`);
-		// continue but do not insert this function into the scope
-		obj = Globals.NewObject(-1, Object.FUNC, ident);
-		obj.typ = typ;
-		// TODO do we need to set the primary type? probably...
-		return obj;
-	}
-
-	// we have a function with the same name
-	if !Type.Equal(typ, obj.typ) {
-		P.Error(-1, `type of "` + ident + `" does not match its forward declaration`);
-		// continue but do not insert this function into the scope
-		obj = Globals.NewObject(-1, Object.FUNC, ident);
-		obj.typ = typ;
-		// TODO do we need to set the primary type? probably...
-		return obj;
-	}
-
-	// We have a matching forward declaration. Use it.
-	return obj;
-}
-
-
-// ----------------------------------------------------------------------------
-// Common productions
-
-
-func (P *Parser) TryType() *Globals.Type;
-func (P *Parser) ParseExpression() Globals.Expr;
-func (P *Parser) TryStatement() bool;
-func (P *Parser) ParseDeclaration();
-
-
-func (P *Parser) ParseIdent(allow_keyword bool) (pos int, ident string) {
-	P.Trace("Ident");
-
-	pos, ident = P.pos, "";
-	// NOTE Can make this faster by not doing the keyword lookup in the
-	// scanner if we don't care about keywords.
-	if P.tok == Scanner.IDENT || allow_keyword && P.tok > Scanner.IDENT {
-		ident = P.val;
-		if P.verbose {
-			P.PrintIndent();
-			print("Ident = \"", ident, "\"\n");
-		}
-		P.Next();
-	} else {
-		P.Expect(Scanner.IDENT);  // use Expect() error handling
-	}
-
-	P.Ecart();
-	return pos, ident;
-}
-
-
-func (P *Parser) ParseIdentDecl(kind int) *Globals.Object {
-	P.Trace("IdentDecl");
-
-	pos, ident := P.ParseIdent(kind == Object.FIELD);
-	obj := Globals.NewObject(pos, kind, ident);
-	P.Declare(obj);
-
-	P.Ecart();
-	return obj;
-}
-
-
-func (P *Parser) ParseIdentDeclList(kind int) *Globals.List {
-	P.Trace("IdentDeclList");
-
-	list := Globals.NewList();
-	list.AddObj(P.ParseIdentDecl(kind));
-	for P.tok == Scanner.COMMA {
-		P.Next();
-		list.AddObj(P.ParseIdentDecl(kind));
-	}
-
-	P.Ecart();
-	return list;
-}
-
-
-func (P *Parser) ParseIdentList() {
-	P.Trace("IdentList");
-	P.ParseIdent(false);
-	for P.tok == Scanner.COMMA {
-		P.Next();
-		P.ParseIdent(false);
-	}
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseQualifiedIdent(pos int, ident string) *Globals.Object {
-	P.Trace("QualifiedIdent");
-
-	if pos < 0 {
-		pos, ident = P.ParseIdent(false);
-	}
-
-	obj := P.Lookup(ident);
-	if obj == nil {
-		P.Error(pos, `"` + ident + `" is not declared`);
-		obj = Globals.NewObject(pos, Object.BAD, ident);
-	}
-
-	if obj.kind == Object.PACKAGE && P.tok == Scanner.PERIOD {
-		if obj.pnolev < 0 {
-			panic("obj.pnolev < 0");
-		}
-		pkg := P.comp.pkg_list[obj.pnolev];
-		//if pkg.obj.ident != ident {
-		//	panic("pkg.obj.ident != ident");
-		//}
-		P.Next();  // consume "."
-		pos, ident = P.ParseIdent(false);
-		obj = pkg.scope.Lookup(ident);
-		if obj == nil {
-			P.Error(pos, `"` + ident + `" is not declared in package "` + pkg.obj.ident + `"`);
-			obj = Globals.NewObject(pos, Object.BAD, ident);
-		}
-	}
-
-	P.Ecart();
-	return obj;
-}
-
-
-// ----------------------------------------------------------------------------
-// Types
-
-func (P *Parser) ParseType() *Globals.Type {
-	P.Trace("Type");
-
-	typ := P.TryType();
-	if typ == nil {
-		P.Error(P.pos, "type expected");
-		typ = Universe.bad_t;
-	}
-
-	P.Ecart();
-	return typ;
-}
-
-
-func (P *Parser) ParseVarType() *Globals.Type {
-	P.Trace("VarType");
-
-	pos := P.pos;
-	typ := P.ParseType();
-
-	switch typ.form {
-	case Type.ARRAY:
-		if P.comp.flags.sixg || typ.len >= 0 {
-			break;
-		}
-		// open arrays must be pointers
-		fallthrough;
-
-	case Type.MAP, Type.CHANNEL, Type.FUNCTION:
-		P.Error(pos, "must be pointer to this type");
-		typ = Universe.bad_t;
-	}
-
-	P.Ecart();
-	return typ;
-}
-
-
-func (P *Parser) ParseTypeName() *Globals.Type {
-	P.Trace("TypeName");
-
-	pos := P.pos;
-	obj := P.ParseQualifiedIdent(-1, "");
-	typ := obj.typ;
-	if obj.kind != Object.TYPE {
-		P.Error(pos, "qualified identifier does not denote a type");
-		typ = Universe.bad_t;
-	}
-
-	P.Ecart();
-	return typ;
-}
-
-
-func (P *Parser) ParseArrayType() *Globals.Type {
-	P.Trace("ArrayType");
-
-	P.Expect(Scanner.LBRACK);
-	typ := Globals.NewType(Type.ARRAY);
-	if P.tok != Scanner.RBRACK {
-		// TODO set typ.len
-		P.ParseExpression();
-	}
-	P.Expect(Scanner.RBRACK);
-	typ.elt = P.ParseVarType();
-
-	P.Ecart();
-	return typ;
-}
-
-
-func (P *Parser) ParseChannelType() *Globals.Type {
-	P.Trace("ChannelType");
-
-	typ := Globals.NewType(Type.CHANNEL);
-	if P.tok == Scanner.CHAN {
-		P.Next();
-		if P.tok == Scanner.ARROW {
-			typ.aux = Type.SEND;
-			P.Next();
-		} else {
-			typ.aux = Type.SEND + Type.RECV;
-		}
-	} else {
-		P.Expect(Scanner.ARROW);
-		P.Expect(Scanner.CHAN);
-		typ.aux = Type.RECV;
-	}
-	typ.elt = P.ParseVarType();
-
-	P.Ecart();
-	return typ;
-}
-
-
-func (P *Parser) ParseVarDeclList(kind int) {
-	P.Trace("VarDeclList");
-
-	list := P.ParseIdentDeclList(kind);
-	typ := P.ParseVarType();
-	for p := list.first; p != nil; p = p.next {
-		p.obj.typ = typ;  // TODO should use/have set_type()
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseParameterList() {
-	P.Trace("ParameterList");
-
-	P.ParseVarDeclList(Object.VAR);
-	for P.tok == Scanner.COMMA {
-		P.Next();
-		P.ParseVarDeclList(Object.VAR);
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseParameters() {
-	P.Trace("Parameters");
-
-	P.Expect(Scanner.LPAREN);
-	if P.tok != Scanner.RPAREN {
-		P.ParseParameterList();
-	}
-	P.Expect(Scanner.RPAREN);
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseResult() {
-	P.Trace("Result");
-
-	if P.tok == Scanner.LPAREN {
-		// one or more named results
-		// TODO: here we allow empty returns - should proably fix this
-		P.ParseParameters();
-
-	} else {
-		// anonymous result
-		pos := P.pos;
-		typ := P.TryType();
-		if typ != nil {
-			obj := Globals.NewObject(pos, Object.VAR, ".res");
-			obj.typ = typ;
-			P.Declare(obj);
-		}
-	}
-
-	P.Ecart();
-}
-
-
-// Signatures
-//
-// (params)
-// (params) type
-// (params) (results)
-
-func (P *Parser) ParseSignature() *Globals.Type {
-	P.Trace("Signature");
-
-	P.OpenScope();
-	P.level--;
-	sig := P.top_scope;
-
-	P.ParseParameters();
-	r0 := sig.entries.len;
-	P.ParseResult();
-
-	P.level++;
-	P.CloseScope();
-
-	P.Ecart();
-	return MakeFunctionType(sig, 0, r0);
-}
-
-
-// Named signatures
-//
-//        ident (params)
-//        ident (params) type
-//        ident (params) (results)
-// (recv) ident (params)
-// (recv) ident (params) type
-// (recv) ident (params) (results)
-
-func (P *Parser) ParseNamedSignature() (pos int, ident string, typ *Globals.Type) {
-	P.Trace("NamedSignature");
-
-	P.OpenScope();
-	P.level--;
-	sig := P.top_scope;
-	p0 := 0;
-
-	if P.tok == Scanner.LPAREN {
-		recv_pos := P.pos;
-		P.ParseParameters();
-		p0 = sig.entries.len;
-		if p0 != 1 {
-			print("p0 = ", p0, "\n");
-			P.Error(recv_pos, "must have exactly one receiver");
-			panic("UNIMPLEMENTED (ParseNamedSignature)");
-			// TODO do something useful here
-		}
-	}
-
-	pos, ident = P.ParseIdent(true);
-
-	P.ParseParameters();
-
-	r0 := sig.entries.len;
-	P.ParseResult();
-	P.level++;
-	P.CloseScope();
-
-	P.Ecart();
-	return pos, ident, MakeFunctionType(sig, p0, r0);
-}
-
-
-func (P *Parser) ParseFunctionType() *Globals.Type {
-	P.Trace("FunctionType");
-
-	typ := P.ParseSignature();
-
-	P.Ecart();
-	return typ;
-}
-
-
-func (P *Parser) ParseMethodDecl(recv_typ *Globals.Type) {
-	P.Trace("MethodDecl");
-
-	pos, ident := P.ParseIdent(true);
-	P.OpenScope();
-	P.level--;
-	sig := P.top_scope;
-
-	// dummy receiver (give it a name so it won't conflict with unnamed result)
-	recv := Globals.NewObject(pos, Object.VAR, ".recv");
-	recv.typ = recv_typ;
-	sig.Insert(recv);
-
-	P.ParseParameters();
-
-	r0 := sig.entries.len;
-	P.ParseResult();
-	P.level++;
-	P.CloseScope();
-	P.Optional(Scanner.SEMICOLON);
-
-	obj := Globals.NewObject(pos, Object.FUNC, ident);
-	obj.typ = MakeFunctionType(sig, 1, r0);
-	P.Declare(obj);
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseInterfaceType() *Globals.Type {
-	P.Trace("InterfaceType");
-
-	P.Expect(Scanner.INTERFACE);
-	P.Expect(Scanner.LBRACE);
-	P.OpenScope();
-	P.level--;
-	typ := Globals.NewType(Type.INTERFACE);
-	typ.scope = P.top_scope;
-	for P.tok >= Scanner.IDENT {
-		P.ParseMethodDecl(typ);
-	}
-	P.level++;
-	P.CloseScope();
-	P.Expect(Scanner.RBRACE);
-
-	P.Ecart();
-	return typ;
-}
-
-
-func (P *Parser) ParseMapType() *Globals.Type {
-	P.Trace("MapType");
-
-	P.Expect(Scanner.MAP);
-	P.Expect(Scanner.LBRACK);
-	typ := Globals.NewType(Type.MAP);
-	typ.key = P.ParseVarType();
-	P.Expect(Scanner.RBRACK);
-	typ.elt = P.ParseVarType();
-	P.Ecart();
-
-	return typ;
-}
-
-
-func (P *Parser) ParseStructType() *Globals.Type {
-	P.Trace("StructType");
-
-	P.Expect(Scanner.STRUCT);
-	P.Expect(Scanner.LBRACE);
-	P.OpenScope();
-	P.level--;
-	typ := Globals.NewType(Type.STRUCT);
-	typ.scope = P.top_scope;
-	for P.tok >= Scanner.IDENT {
-		P.ParseVarDeclList(Object.FIELD);
-		if P.tok != Scanner.RBRACE {
-			P.Expect(Scanner.SEMICOLON);
-		}
-	}
-	P.Optional(Scanner.SEMICOLON);
-	P.level++;
-	P.CloseScope();
-	P.Expect(Scanner.RBRACE);
-
-	P.Ecart();
-	return typ;
-}
-
-
-func (P *Parser) ParsePointerType() *Globals.Type {
-	P.Trace("PointerType");
-
-	P.Expect(Scanner.MUL);
-	typ := Globals.NewType(Type.POINTER);
-
-	var elt *Globals.Type;
-	if P.tok == Scanner.STRING && !P.comp.flags.sixg {
-		// implicit package.type forward declaration
-		// TODO eventually the scanner should strip the quotes
-		pkg_name := P.val[1 : len(P.val) - 1];  // strip quotes
-		pkg := P.comp.Lookup(pkg_name);
-		if pkg == nil {
-			// package doesn't exist yet - add it to the package list
-			obj := Globals.NewObject(P.pos, Object.PACKAGE, ".pkg");
-			pkg = Globals.NewPackage(pkg_name, obj, Globals.NewScope(nil));
-			pkg.key = "";  // mark as forward-declared package
-			P.comp.Insert(pkg);
-		} else {
-			// package exists already - must be forward declaration
-			if pkg.key != "" {
-				P.Error(P.pos, `cannot use implicit package forward declaration for imported package "` + P.val + `"`);
-				panic("wrong package forward decl");
-				// TODO introduce dummy package so we can continue safely
-			}
-		}
-
-		P.Next();  // consume package name
-		P.Expect(Scanner.PERIOD);
-		pos, ident := P.ParseIdent(false);
-		obj := pkg.scope.Lookup(ident);
-		if obj == nil {
-			elt = Globals.NewType(Type.FORWARD);
-			elt.scope = P.top_scope;  // not really needed here, but for consistency
-			obj = Globals.NewObject(pos, Object.TYPE, ident);
-			obj.exported = true;  // the type name must be visible
-			obj.typ = elt;
-			elt.obj = obj;  // primary type object;
-			pkg.scope.Insert(obj);
-			obj.pnolev = pkg.obj.pnolev;
-		} else {
-			if obj.kind != Object.TYPE || obj.typ.form != Type.FORWARD {
-				panic("inconsistency in package.type forward declaration");
-			}
-			elt = obj.typ;
-		}
-
-	} else if P.tok == Scanner.IDENT {
-		if P.Lookup(P.val) == nil {
-			// implicit type forward declaration
-			// create a named forward type
-			pos, ident := P.ParseIdent(false);
-			obj := Globals.NewObject(pos, Object.TYPE, ident);
-			elt = Globals.NewType(Type.FORWARD);
-			obj.typ = elt;
-			elt.obj = obj;  // primary type object;
-			// remember the current scope - resolving the forward
-			// type must find a matching declaration in this or a less nested scope
-			elt.scope = P.top_scope;
-
-				// create a named forward type
-
-		} else {
-			// type name
-			// (ParseType() (via TryType()) checks for forward types and complains,
-			// so call ParseTypeName() directly)
-			// we can only have a foward type here if we refer to the name of a
-			// yet incomplete type (i.e. if we are in the middle of a type's declaration)
-			elt = P.ParseTypeName();
-		}
-
-		// collect uses of pointer types referring to forward types
-		if elt.form == Type.FORWARD {
-			P.forward_types.AddTyp(typ);
-		}
-
-	} else {
-		elt = P.ParseType();
-	}
-
-
-	typ.elt = elt;
-
-	P.Ecart();
-	return typ;
-}
-
-
-// Returns nil if no type was found.
-func (P *Parser) TryType() *Globals.Type {
-	P.Trace("Type (try)");
-
-	pos := P.pos;
-	var typ *Globals.Type = nil;
-	switch P.tok {
-	case Scanner.IDENT: typ = P.ParseTypeName();
-	case Scanner.LBRACK: typ = P.ParseArrayType();
-	case Scanner.CHAN, Scanner.ARROW: typ = P.ParseChannelType();
-	case Scanner.INTERFACE: typ = P.ParseInterfaceType();
-	case Scanner.LPAREN: typ = P.ParseFunctionType();
-	case Scanner.MAP: typ = P.ParseMapType();
-	case Scanner.STRUCT: typ = P.ParseStructType();
-	case Scanner.MUL: typ = P.ParsePointerType();
-	}
-
-	if typ != nil && typ.form == Type.FORWARD {
-		P.Error(pos, "incomplete type");
-	}
-
-	P.Ecart();
-	return typ;
-}
-
-
-// ----------------------------------------------------------------------------
-// Blocks
-
-func (P *Parser) ParseStatement() {
-	P.Trace("Statement");
-	if !P.TryStatement() {
-		P.Error(P.pos, "statement expected");
-		P.Next();  // make progress
-	}
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseStatementList() {
-	P.Trace("StatementList");
-	for P.TryStatement() {
-		P.Optional(Scanner.SEMICOLON);
-	}
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseBlock(sig *Globals.Scope) {
-	P.Trace("Block");
-
-	P.Expect(Scanner.LBRACE);
-	P.OpenScope();
-	if sig != nil {
-		P.level--;
-		// add copies of the formal parameters to the function scope
-		scope := P.top_scope;
-		for p := sig.entries.first; p != nil; p = p.next {
-			scope.Insert(p.obj.Copy())
-		}
-	}
-	if P.tok != Scanner.RBRACE && P.tok != Scanner.SEMICOLON {
-		P.ParseStatementList();
-	}
-	P.Optional(Scanner.SEMICOLON);
-	if sig != nil {
-		P.level++;
-	}
-	P.CloseScope();
-	P.Expect(Scanner.RBRACE);
-
-	P.Ecart();
-}
-
-
-// ----------------------------------------------------------------------------
-// Expressions
-
-func (P *Parser) ParseExpressionList(list *Globals.List) {
-	P.Trace("ExpressionList");
-
-	list.AddExpr(P.ParseExpression());
-	for P.tok == Scanner.COMMA {
-		P.Next();
-		list.AddExpr(P.ParseExpression());
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseNewExpressionList() *Globals.List {
-	P.Trace("NewExpressionList");
-
-	list := Globals.NewList();
-	P.ParseExpressionList(list);
-
-	P.Ecart();
-	return list;
-}
-
-
-func (P *Parser) ParseFunctionLit() Globals.Expr {
-	P.Trace("FunctionLit");
-
-	P.Expect(Scanner.FUNC);
-	typ := P.ParseFunctionType();
-	P.ParseBlock(typ.scope);
-
-	P.Ecart();
-	return nil;
-}
-
-
-func (P *Parser) ParseExpressionPair(list *Globals.List) {
-	P.Trace("ExpressionPair");
-
-	list.AddExpr(P.ParseExpression());
-	P.Expect(Scanner.COLON);
-	list.AddExpr(P.ParseExpression());
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseExpressionPairList(list *Globals.List) {
-	P.Trace("ExpressionPairList");
-
-	P.ParseExpressionPair(list);
-	for (P.tok == Scanner.COMMA) {
-		P.ParseExpressionPair(list);
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseCompositeLit(typ *Globals.Type) Globals.Expr {
-	P.Trace("CompositeLit");
-
-	P.Expect(Scanner.LBRACE);
-	// TODO: should allow trailing ','
-	list := Globals.NewList();
-	if P.tok != Scanner.RBRACE {
-		list.AddExpr(P.ParseExpression());
-		if P.tok == Scanner.COMMA {
-			P.Next();
-			if P.tok != Scanner.RBRACE {
-				P.ParseExpressionList(list);
-			}
-		} else if P.tok == Scanner.COLON {
-			P.Next();
-			list.AddExpr(P.ParseExpression());
-			if P.tok == Scanner.COMMA {
-				P.Next();
-				if P.tok != Scanner.RBRACE {
-					P.ParseExpressionPairList(list);
-				}
-			}
-		}
-	}
-	P.Expect(Scanner.RBRACE);
-
-	P.Ecart();
-	return nil;
-}
-
-
-func (P *Parser) ParseOperand(pos int, ident string) Globals.Expr {
-	P.Trace("Operand");
-
-	if pos < 0 && P.tok == Scanner.IDENT {
-		// no look-ahead yet
-		pos = P.pos;
-		ident = P.val;
-		P.Next();
-	}
-
-	var res Globals.Expr = AST.Bad;
-
-	if pos >= 0 {
-		// we have an identifier
-		obj := P.ParseQualifiedIdent(pos, ident);
-		if obj.kind == Object.TYPE && P.tok == Scanner.LBRACE {
-			res = P.ParseCompositeLit(obj.typ);
-		} else {
-			res = AST.NewObject(pos, obj);
-		}
-
-	} else {
-
-		switch P.tok {
-		case Scanner.IDENT:
-			panic("UNREACHABLE");
-
-		case Scanner.LPAREN:
-			P.Next();
-			res = P.ParseExpression();
-			P.Expect(Scanner.RPAREN);
-
-		case Scanner.INT:
-			x := AST.NewLiteral(P.pos, Universe.int_t);
-			x.i = 42;  // TODO set the right value
-			res = x;
-			P.Next();
-
-		case Scanner.FLOAT:
-			x := AST.NewLiteral(P.pos, Universe.float_t);
-			x.f = 42.0;  // TODO set the right value
-			res = x;
-			P.Next();
-
-		case Scanner.STRING:
-			x := AST.NewLiteral(P.pos, Universe.string_t);
-			x.s = P.val;  // TODO need to strip quotes, interpret string properly
-			res = x;
-			P.Next();
-
-		case Scanner.FUNC:
-			res = P.ParseFunctionLit();
-		default:
-			typ := P.TryType();
-			if typ != nil {
-				res = P.ParseCompositeLit(typ);
-			} else {
-				P.Error(P.pos, "operand expected");
-				P.Next();  // make progress
-			}
-		}
-
-	}
-
-	P.Ecart();
-	return res;
-}
-
-
-func (P *Parser) ParseSelectorOrTypeAssertion(x Globals.Expr) Globals.Expr {
-	P.Trace("SelectorOrTypeAssertion");
-
-	P.Expect(Scanner.PERIOD);
-	pos := P.pos;
-
-	if P.tok >= Scanner.IDENT {
-		pos, selector := P.ParseIdent(true);
-		x = Expr.Select(P.comp, x, pos, selector);
-	} else {
-		P.Expect(Scanner.LPAREN);
-		typ := P.ParseType();
-		P.Expect(Scanner.RPAREN);
-		x = Expr.AssertType(P.comp, x, pos, typ);
-	}
-
-	P.Ecart();
-	return x;
-}
-
-
-func (P *Parser) ParseIndexOrSlice(x Globals.Expr) Globals.Expr {
-	P.Trace("IndexOrSlice");
-
-	P.Expect(Scanner.LBRACK);
-	i := P.ParseExpression();
-	if P.tok == Scanner.COLON {
-		P.Next();
-		j := P.ParseExpression();
-		x = Expr.Slice(P.comp, x, i, j);
-	} else {
-		x = Expr.Index(P.comp, x, i);
-	}
-	P.Expect(Scanner.RBRACK);
-
-	P.Ecart();
-	return x;
-}
-
-
-func (P *Parser) ParseCall(x Globals.Expr) Globals.Expr {
-	P.Trace("Call");
-
-	P.Expect(Scanner.LPAREN);
-	args := Globals.NewList();
-	if P.tok != Scanner.RPAREN {
-		P.ParseExpressionList(args);
-	}
-	P.Expect(Scanner.RPAREN);
-	x = Expr.Call(P.comp, x, args);
-
-	P.Ecart();
-	return x;
-}
-
-
-func (P *Parser) ParsePrimaryExpr(pos int, ident string) Globals.Expr {
-	P.Trace("PrimaryExpr");
-
-	x := P.ParseOperand(pos, ident);
-	for {
-		switch P.tok {
-		case Scanner.PERIOD: x = P.ParseSelectorOrTypeAssertion(x);
-		case Scanner.LBRACK: x = P.ParseIndexOrSlice(x);
-		case Scanner.LPAREN: x = P.ParseCall(x);
-		default: goto exit;
-		}
-	}
-
-exit:
-	P.Ecart();
-	return x;
-}
-
-
-// TODO is this function needed?
-func (P *Parser) ParsePrimaryExprList() *Globals.List {
-	P.Trace("PrimaryExprList");
-
-	list := Globals.NewList();
-	list.AddExpr(P.ParsePrimaryExpr(-1, ""));
-	for P.tok == Scanner.COMMA {
-		P.Next();
-		list.AddExpr(P.ParsePrimaryExpr(-1, ""));
-	}
-
-	P.Ecart();
-	return list;
-}
-
-
-func (P *Parser) ParseUnaryExpr() Globals.Expr {
-	P.Trace("UnaryExpr");
-
-	switch P.tok {
-	case Scanner.ADD: fallthrough;
-	case Scanner.SUB: fallthrough;
-	case Scanner.NOT: fallthrough;
-	case Scanner.XOR: fallthrough;
-	case Scanner.MUL: fallthrough;
-	case Scanner.ARROW: fallthrough;
-	case Scanner.AND:
-		P.Next();
-		x := P.ParseUnaryExpr();
-		P.Ecart();
-		return x;  // TODO fix this
-	}
-
-	x := P.ParsePrimaryExpr(-1, "");
-
-	P.Ecart();
-	return x;  // TODO fix this
-}
-
-
-func Precedence(tok int) int {
-	// TODO should use a map or array here for lookup
-	switch tok {
-	case Scanner.LOR:
-		return 1;
-	case Scanner.LAND:
-		return 2;
-	case Scanner.ARROW:
-		return 3;
-	case Scanner.EQL, Scanner.NEQ, Scanner.LSS, Scanner.LEQ, Scanner.GTR, Scanner.GEQ:
-		return 4;
-	case Scanner.ADD, Scanner.SUB, Scanner.OR, Scanner.XOR:
-		return 5;
-	case Scanner.MUL, Scanner.QUO, Scanner.REM, Scanner.SHL, Scanner.SHR, Scanner.AND:
-		return 6;
-	}
-	return 0;
-}
-
-
-func (P *Parser) ParseBinaryExpr(pos int, ident string, prec1 int) Globals.Expr {
-	P.Trace("BinaryExpr");
-
-	var x Globals.Expr;
-	if pos >= 0 {
-		x = P.ParsePrimaryExpr(pos, ident);
-	} else {
-		x = P.ParseUnaryExpr();
-	}
-
-	for prec := Precedence(P.tok); prec >= prec1; prec-- {
-		for Precedence(P.tok) == prec {
-			P.Next();
-			y := P.ParseBinaryExpr(-1, "", prec + 1);
-			x = Expr.BinaryExpr(P.comp, x, y);
-		}
-	}
-
-	P.Ecart();
-	return x;
-}
-
-
-// Expressions where the first token may be an identifier which has already
-// been consumed. If the identifier is present, pos is the identifier position,
-// otherwise pos must be < 0 (and ident is ignored).
-func (P *Parser) ParseIdentExpression(pos int, ident string) Globals.Expr {
-	P.Trace("IdentExpression");
-	indent := P.indent;
-
-	x := P.ParseBinaryExpr(pos, ident, 1);
-
-	if indent != P.indent {
-		panic("imbalanced tracing code (Expression)");
-	}
-	P.Ecart();
-	return x;
-}
-
-
-func (P *Parser) ParseExpression() Globals.Expr {
-	P.Trace("Expression");
-
-	x := P.ParseIdentExpression(-1, "");
-
-	P.Ecart();
-	return x;
-}
-
-
-// ----------------------------------------------------------------------------
-// Statements
-
-func (P *Parser) ConvertToExprList(pos_list, ident_list, expr_list *Globals.List) {
-	if pos_list.len != ident_list.len {
-		panic("inconsistent lists");
-	}
-	for p, q := pos_list.first, ident_list.first; q != nil; p, q = p.next, q.next {
-		pos, ident := p.val, q.str;
-		obj := P.Lookup(ident);
-		if obj == nil {
-			P.Error(pos, `"` + ident + `" is not declared`);
-			obj = Globals.NewObject(pos, Object.BAD, ident);
-		}
-		expr_list.AddExpr(AST.NewObject(pos, obj));
-	}
-	pos_list.Clear();
-	ident_list.Clear();
-}
-
-
-func (P *Parser) ParseIdentOrExpr(pos_list, ident_list, expr_list *Globals.List) {
-	P.Trace("IdentOrExpr");
-
-	pos, ident := -1, "";
-	just_ident := false;
-	if expr_list.len == 0 /* only idents so far */ && P.tok == Scanner.IDENT {
-		pos, ident = P.pos, P.val;
-		P.Next();
-		switch P.tok {
-		case Scanner.COMMA,
-			Scanner.COLON,
-			Scanner.DEFINE,
-			Scanner.ASSIGN,
-			Scanner.ADD_ASSIGN,
-			Scanner.SUB_ASSIGN,
-			Scanner.MUL_ASSIGN,
-			Scanner.QUO_ASSIGN,
-			Scanner.REM_ASSIGN,
-			Scanner.AND_ASSIGN,
-			Scanner.OR_ASSIGN,
-			Scanner.XOR_ASSIGN,
-			Scanner.SHL_ASSIGN,
-			Scanner.SHR_ASSIGN:
-			// identifier is *not* part of a more complicated expression
-			just_ident = true;
-		}
-	}
-
-	if just_ident {
-		pos_list.AddInt(pos);
-		ident_list.AddStr(ident);
-	} else {
-		P.ConvertToExprList(pos_list, ident_list, expr_list);
-		expr_list.AddExpr(P.ParseIdentExpression(pos, ident));
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseIdentOrExprList() (pos_list, ident_list, expr_list *Globals.List) {
-	P.Trace("IdentOrExprList");
-
-	pos_list, ident_list = Globals.NewList(), Globals.NewList();  // "pairs" of (pos, ident)
-	expr_list = Globals.NewList();
-
-	P.ParseIdentOrExpr(pos_list, ident_list, expr_list);
-	for P.tok == Scanner.COMMA {
-		P.Next();
-		P.ParseIdentOrExpr(pos_list, ident_list, expr_list);
-	}
-
-	P.Ecart();
-	return pos_list, ident_list, expr_list;
-}
-
-
-// Compute the number of individual values provided by the expression list.
-func (P *Parser) ListArity(list *Globals.List) int {
-	if list.len == 1 {
-		x := list.ExprAt(0);
-		if x.op() == AST.CALL {
-			panic("UNIMPLEMENTED");
-		}
-		return 1;
-	} else {
-		for p := list.first; p != nil; p = p.next {
-			x := p.expr;
-			if x.op() == AST.CALL {
-				panic("UNIMPLEMENTED");
-			}
-		}
-	}
-	panic("UNREACHABLE");
-}
-
-
-func (P *Parser) ParseSimpleStat() {
-	P.Trace("SimpleStat");
-
-	// If we see an identifier, we don't know if it's part of a
-	// label declaration, (multiple) variable declaration, assignment,
-	// or simply an expression, without looking ahead.
-	// Strategy: We parse an expression list, but simultaneously, as
-	// long as possible, maintain a list of identifiers which is converted
-	// into an expression list only if neccessary. The result of
-	// ParseIdentOrExprList is a pair of non-empty lists of identfiers and
-	// their respective source positions, or a non-empty list of expressions
-	// (but not both).
-	pos_list, ident_list, expr_list := P.ParseIdentOrExprList();
-
-	switch P.tok {
-	case Scanner.COLON:
-		// label declaration
-		if ident_list.len == 1 {
-			obj := Globals.NewObject(pos_list.first.val, Object.LABEL, ident_list.first.str);
-			P.Declare(obj);
-		} else {
-			P.Error(P.pos, "illegal label declaration");
-		}
-		P.Next();  // consume ":"
-
-	case Scanner.DEFINE:
-		// variable declaration
-		if ident_list.len == 0 {
-			P.Error(P.pos, "illegal left-hand side for declaration");
-		}
-		P.Next();  // consume ":="
-		val_list := P.ParseNewExpressionList();
-		if val_list.len != ident_list.len {
-			P.Error(val_list.first.expr.pos(), "number of expressions does not match number of variables");
-		}
-		// declare variables
-		for p, q := pos_list.first, ident_list.first; q != nil; p, q = p.next, q.next {
-			obj := Globals.NewObject(p.val, Object.VAR, q.str);
-			P.Declare(obj);
-			// TODO set correct types
-			obj.typ = Universe.bad_t;  // for now
-		}
-
-	case Scanner.ASSIGN: fallthrough;
-	case Scanner.ADD_ASSIGN: fallthrough;
-	case Scanner.SUB_ASSIGN: fallthrough;
-	case Scanner.MUL_ASSIGN: fallthrough;
-	case Scanner.QUO_ASSIGN: fallthrough;
-	case Scanner.REM_ASSIGN: fallthrough;
-	case Scanner.AND_ASSIGN: fallthrough;
-	case Scanner.OR_ASSIGN: fallthrough;
-	case Scanner.XOR_ASSIGN: fallthrough;
-	case Scanner.SHL_ASSIGN: fallthrough;
-	case Scanner.SHR_ASSIGN:
-		P.ConvertToExprList(pos_list, ident_list, expr_list);
-		P.Next();
-		pos := P.pos;
-		val_list := P.ParseNewExpressionList();
-
-		// assign variables
-		if val_list.len == 1 && val_list.first.expr.typ().form == Type.TUPLE {
-			panic("UNIMPLEMENTED");
-		} else {
-			var p, q *Globals.Elem;
-			for p, q = expr_list.first, val_list.first; p != nil && q != nil; p, q = p.next, q.next {
-
-			}
-			if p != nil || q != nil {
-				P.Error(pos, "number of expressions does not match number of variables");
-			}
-		}
-
-	default:
-		P.ConvertToExprList(pos_list, ident_list, expr_list);
-		if expr_list.len != 1 {
-			P.Error(P.pos, "no expression list allowed");
-		}
-		if P.tok == Scanner.INC || P.tok == Scanner.DEC {
-			P.Next();
-		}
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseGoStat() {
-	P.Trace("GoStat");
-
-	P.Expect(Scanner.GO);
-	P.ParseExpression();
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseReturnStat() {
-	P.Trace("ReturnStat");
-
-	P.Expect(Scanner.RETURN);
-	res := Globals.NewList();
-	if P.tok != Scanner.SEMICOLON && P.tok != Scanner.RBRACE {
-		P.ParseExpressionList(res);
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseControlFlowStat(tok int) {
-	P.Trace("ControlFlowStat");
-
-	P.Expect(tok);
-	if P.tok == Scanner.IDENT {
-		P.ParseIdent(false);
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseIfStat() *AST.IfStat {
-	P.Trace("IfStat");
-
-	P.Expect(Scanner.IF);
-	P.OpenScope();
-	if P.tok != Scanner.LBRACE {
-		if P.tok != Scanner.SEMICOLON {
-			P.ParseSimpleStat();
-		}
-		if P.tok == Scanner.SEMICOLON {
-			P.Next();
-			if P.tok != Scanner.LBRACE {
-				P.ParseExpression();
-			}
-		}
-	}
-	P.ParseBlock(nil);
-	if P.tok == Scanner.ELSE {
-		P.Next();
-		if P.tok == Scanner.IF {
-			P.ParseIfStat();
-		} else {
-			// TODO should be P.ParseBlock()
-			P.ParseStatement();
-		}
-	}
-	P.CloseScope();
-
-	P.Ecart();
-	return nil;
-}
-
-
-func (P *Parser) ParseForStat() {
-	P.Trace("ForStat");
-
-	P.Expect(Scanner.FOR);
-	P.OpenScope();
-	if P.tok != Scanner.LBRACE {
-		if P.tok != Scanner.SEMICOLON {
-			P.ParseSimpleStat();
-		}
-		if P.tok == Scanner.SEMICOLON {
-			P.Next();
-			if P.tok != Scanner.SEMICOLON {
-				P.ParseExpression();
-			}
-			P.Expect(Scanner.SEMICOLON);
-			if P.tok != Scanner.LBRACE {
-				P.ParseSimpleStat();
-			}
-		}
-	}
-	P.ParseBlock(nil);
-	P.CloseScope();
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseCase() {
-	P.Trace("Case");
-
-	if P.tok == Scanner.CASE {
-		P.Next();
-		list := Globals.NewList();
-		P.ParseExpressionList(list);
-	} else {
-		P.Expect(Scanner.DEFAULT);
-	}
-	P.Expect(Scanner.COLON);
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseCaseClause() {
-	P.Trace("CaseClause");
-
-	P.ParseCase();
-	if P.tok != Scanner.FALLTHROUGH && P.tok != Scanner.RBRACE {
-		P.ParseStatementList();
-		P.Optional(Scanner.SEMICOLON);
-	}
-	if P.tok == Scanner.FALLTHROUGH {
-		P.Next();
-		P.Optional(Scanner.SEMICOLON);
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseSwitchStat() {
-	P.Trace("SwitchStat");
-
-	P.Expect(Scanner.SWITCH);
-	P.OpenScope();
-	if P.tok != Scanner.LBRACE {
-		if P.tok != Scanner.SEMICOLON {
-			P.ParseSimpleStat();
-		}
-		if P.tok == Scanner.SEMICOLON {
-			P.Next();
-			if P.tok != Scanner.LBRACE {
-				P.ParseExpression();
-			}
-		}
-	}
-	P.Expect(Scanner.LBRACE);
-	for P.tok == Scanner.CASE || P.tok == Scanner.DEFAULT {
-		P.ParseCaseClause();
-	}
-	P.Expect(Scanner.RBRACE);
-	P.CloseScope();
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseCommCase() {
-  P.Trace("CommCase");
-
-  if P.tok == Scanner.CASE {
-	P.Next();
-	if P.tok == Scanner.GTR {
-		// send
-		P.Next();
-		P.ParseExpression();
-		P.Expect(Scanner.EQL);
-		P.ParseExpression();
-	} else {
-		// receive
-		if P.tok != Scanner.LSS {
-			P.ParseIdent(false);
-			P.Expect(Scanner.ASSIGN);
-		}
-		P.Expect(Scanner.LSS);
-		P.ParseExpression();
-	}
-  } else {
-	P.Expect(Scanner.DEFAULT);
-  }
-  P.Expect(Scanner.COLON);
-
-  P.Ecart();
-}
-
-
-func (P *Parser) ParseCommClause() {
-	P.Trace("CommClause");
-
-	P.ParseCommCase();
-	if P.tok != Scanner.CASE && P.tok != Scanner.DEFAULT && P.tok != Scanner.RBRACE {
-		P.ParseStatementList();
-		P.Optional(Scanner.SEMICOLON);
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseRangeStat() {
-	P.Trace("RangeStat");
-
-	P.Expect(Scanner.RANGE);
-	P.ParseIdentList();
-	P.Expect(Scanner.DEFINE);
-	P.ParseExpression();
-	P.ParseBlock(nil);
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseSelectStat() {
-	P.Trace("SelectStat");
-
-	P.Expect(Scanner.SELECT);
-	P.Expect(Scanner.LBRACE);
-	for P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
-		P.ParseCommClause();
-	}
-	P.Next();
-
-	P.Ecart();
-}
-
-
-func (P *Parser) TryStatement() bool {
-	P.Trace("Statement (try)");
-	indent := P.indent;
-
-	res := true;
-	switch P.tok {
-	case Scanner.CONST: fallthrough;
-	case Scanner.TYPE: fallthrough;
-	case Scanner.VAR:
-		P.ParseDeclaration();
-	case Scanner.FUNC:
-		// for now we do not allow local function declarations
-		fallthrough;
-	case Scanner.MUL, Scanner.ARROW, Scanner.IDENT, Scanner.LPAREN:
-		P.ParseSimpleStat();
-	case Scanner.GO:
-		P.ParseGoStat();
-	case Scanner.RETURN:
-		P.ParseReturnStat();
-	case Scanner.BREAK, Scanner.CONTINUE, Scanner.GOTO:
-		P.ParseControlFlowStat(P.tok);
-	case Scanner.LBRACE:
-		P.ParseBlock(nil);
-	case Scanner.IF:
-		P.ParseIfStat();
-	case Scanner.FOR:
-		P.ParseForStat();
-	case Scanner.SWITCH:
-		P.ParseSwitchStat();
-	case Scanner.RANGE:
-		P.ParseRangeStat();
-	case Scanner.SELECT:
-		P.ParseSelectStat();
-	default:
-		// no statement found
-		res = false;
-	}
-
-	if indent != P.indent {
-		panic("imbalanced tracing code (Statement)");
-	}
-	P.Ecart();
-	return res;
-}
-
-
-// ----------------------------------------------------------------------------
-// Declarations
-
-func (P *Parser) ParseImportSpec() {
-	P.Trace("ImportSpec");
-
-	var obj *Globals.Object = nil;
-	if P.tok == Scanner.PERIOD {
-		P.Error(P.pos, `"import ." not yet handled properly`);
-		P.Next();
-	} else if P.tok == Scanner.IDENT {
-		obj = P.ParseIdentDecl(Object.PACKAGE);
-	}
-
-	if P.tok == Scanner.STRING {
-		// TODO eventually the scanner should strip the quotes
-		pkg_name := P.val[1 : len(P.val) - 1];  // strip quotes
-		pkg := P.comp.env.Import(P.comp, pkg_name);
-		if pkg != nil {
-			pno := pkg.obj.pnolev;  // preserve pno
-			if obj == nil {
-				// use original package name
-				obj = pkg.obj;
-				P.Declare(obj);  // this changes (pkg.)obj.pnolev!
-			}
-			obj.pnolev = pno;  // reset pno
-		} else {
-			P.Error(P.pos, `import of "` + pkg_name + `" failed`);
-		}
-		P.Next();
-	} else {
-		P.Expect(Scanner.STRING);  // use Expect() error handling
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseConstSpec(exported bool) {
-	P.Trace("ConstSpec");
-
-	list := P.ParseIdentDeclList(Object.CONST);
-	typ := P.TryType();
-	if typ != nil {
-		for p := list.first; p != nil; p = p.next {
-			p.obj.typ = typ;
-		}
-	}
-
-	if P.tok == Scanner.ASSIGN {
-		P.Next();
-		P.ParseNewExpressionList();
-	}
-
-	if exported {
-		for p := list.first; p != nil; p = p.next {
-			p.obj.exported = true;
-		}
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseTypeSpec(exported bool) {
-	P.Trace("TypeSpec");
-
-	var typ *Globals.Type;
-
-	pos, ident := P.ParseIdent(false);
-	obj := P.Lookup(ident);
-
-	if !P.comp.flags.sixg && obj != nil {
-		if obj.typ.form == Type.FORWARD {
-			// imported forward-declared type
-			if !exported {
-				panic("foo");
-			}
-		} else {
-			panic("bar");
-		}
-
-	} else {
-		// Immediately after declaration of the type name, the type is
-		// considered forward-declared. It may be referred to from inside
-		// the type specification only via a pointer type.
-		typ = Globals.NewType(Type.FORWARD);
-		typ.scope = P.top_scope;  // not really needed here, but for consistency
-
-		obj = Globals.NewObject(pos, Object.TYPE, ident);
-		obj.exported = exported;
-		obj.typ = typ;
-		typ.obj = obj;  // primary type object
-		P.Declare(obj);
-	}
-
-	// If the next token is an identifier and we have a legal program,
-	// it must be a typename. In that case this declaration introduces
-	// an alias type.
-	if P.tok == Scanner.IDENT {
-		typ = Globals.NewType(Type.ALIAS);
-		elt := P.ParseType();  // we want a complete type - don't shortcut to ParseTypeName()
-		typ.elt = elt;
-		if elt.form == Type.ALIAS {
-			typ.key = elt.key;  // the base type
-		} else {
-			typ.key = elt;
-		}
-	} else {
-		typ = P.ParseType();
-	}
-
-	obj.typ = typ;
-	if typ.obj == nil {
-		typ.obj = obj;  // primary type object
-	}
-
-	// if the type is exported, for now we export all fields
-	// of structs and interfaces by default
-	// TODO this needs to change eventually
-	// Actually in 6g even types referred to are exported - sigh...
-	if exported && (typ.form == Type.STRUCT || typ.form == Type.INTERFACE) {
-		for p := typ.scope.entries.first; p != nil; p = p.next {
-			p.obj.exported = true;
-		}
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseVarSpec(exported bool) {
-	P.Trace("VarSpec");
-
-	list := P.ParseIdentDeclList(Object.VAR);
-	if P.tok == Scanner.ASSIGN {
-		P.Next();
-		P.ParseNewExpressionList();
-	} else {
-		typ := P.ParseVarType();
-		for p := list.first; p != nil; p = p.next {
-			p.obj.typ = typ;
-		}
-		if P.tok == Scanner.ASSIGN {
-			P.Next();
-			P.ParseNewExpressionList();
-		}
-	}
-
-	if exported {
-		for p := list.first; p != nil; p = p.next {
-			p.obj.exported = true;
-		}
-	}
-
-	P.Ecart();
-}
-
-
-// TODO With method variables, we wouldn't need this dispatch function.
-func (P *Parser) ParseSpec(exported bool, keyword int) {
-	switch keyword {
-	case Scanner.IMPORT: P.ParseImportSpec();
-	case Scanner.CONST: P.ParseConstSpec(exported);
-	case Scanner.TYPE: P.ParseTypeSpec(exported);
-	case Scanner.VAR: P.ParseVarSpec(exported);
-	default: panic("UNREACHABLE");
-	}
-}
-
-
-func (P *Parser) ParseDecl(exported bool, keyword int) {
-	P.Trace("Decl");
-
-	P.Expect(keyword);
-	if P.tok == Scanner.LPAREN {
-		P.Next();
-		for P.tok == Scanner.IDENT {
-			P.ParseSpec(exported, keyword);
-			if P.tok != Scanner.RPAREN {
-				// P.Expect(Scanner.SEMICOLON);
-				P.Optional(Scanner.SEMICOLON);  // TODO this seems wrong! (needed for math.go)
-			}
-		}
-		P.Next();
-	} else {
-		P.ParseSpec(exported, keyword);
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseFuncDecl(exported bool) {
-	P.Trace("FuncDecl");
-
-	P.Expect(Scanner.FUNC);
-	pos, ident, typ := P.ParseNamedSignature();
-	obj := P.DeclareFunc(pos, ident, typ);  // need obj later for statements
-	obj.exported = exported;
-	if P.tok == Scanner.SEMICOLON {
-		// forward declaration
-		P.Next();
-	} else {
-		P.ParseBlock(typ.scope);
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseExportDecl() {
-	P.Trace("ExportDecl");
-
-	// TODO This is deprecated syntax and should go away eventually.
-	// (Also at the moment the syntax is everything goes...)
-	//P.Expect(Scanner.EXPORT);
-
-	if !P.comp.flags.sixg {
-		P.Error(P.pos, "deprecated export syntax (use -6g to enable)");
-	}
-
-	has_paren := false;
-	if P.tok == Scanner.LPAREN {
-		P.Next();
-		has_paren = true;
-	}
-	for P.tok == Scanner.IDENT {
-		pos, ident := P.ParseIdent(false);
-		P.exports.AddStr(ident);
-		P.Optional(Scanner.COMMA);  // TODO this seems wrong
-	}
-	if has_paren {
-		P.Expect(Scanner.RPAREN)
-	}
-
-	P.Ecart();
-}
-
-
-func (P *Parser) ParseDeclaration() {
-	P.Trace("Declaration");
-	indent := P.indent;
-
-	exported := false;
-	if P.tok == Scanner.EXPORT {
-		if P.level == 0 {
-			exported = true;
-		} else {
-			P.Error(P.pos, "local declarations cannot be exported");
-		}
-		P.Next();
-	}
-
-	switch P.tok {
-	case Scanner.CONST, Scanner.TYPE, Scanner.VAR:
-		P.ParseDecl(exported, P.tok);
-	case Scanner.FUNC:
-		P.ParseFuncDecl(exported);
-	case Scanner.EXPORT:
-		if exported {
-			P.Error(P.pos, "cannot mark export declaration for export");
-		}
-		P.Next();
-		P.ParseExportDecl();
-	default:
-		if exported && (P.tok == Scanner.IDENT || P.tok == Scanner.LPAREN) {
-			P.ParseExportDecl();
-		} else {
-			P.Error(P.pos, "declaration expected");
-			P.Next();  // make progress
-		}
-	}
-
-	if indent != P.indent {
-		panic("imbalanced tracing code (Declaration)");
-	}
-	P.Ecart();
-}
-
-
-// ----------------------------------------------------------------------------
-// Program
-
-func (P *Parser) ResolveForwardTypes() {
-	for p := P.forward_types.first; p != nil; p = p.next {
-		typ := p.typ;
-		if typ.form != Type.POINTER {
-			panic("unresolved types should be pointers only");
-		}
-
-		elt := typ.elt;
-		if typ.elt.form != Type.FORWARD {
-			panic("unresolved pointer should point to forward type");
-		}
-
-		obj := elt.obj;
-		if obj.typ == elt {
-			// actual forward declaration (as opposed to forward types introduced
-			// during type declaration) - need to lookup the actual type object
-			var elt_obj *Globals.Object;
-			for scope := elt.scope; scope != nil && elt_obj == nil; scope = scope.parent {
-				elt_obj = scope.Lookup(obj.ident);
-			}
-			// update the type object if we found one
-			if elt_obj != nil {
-				if elt_obj.kind == Object.TYPE {
-					obj = elt_obj;
-				} else {
-					P.Error(obj.pos, `"` + obj.ident + `" does not denote a type`);
-				}
-			}
-		}
-
-		// update the pointer type
-		typ.elt = obj.typ;
-
-		// TODO as long as we don't *use* a forward type, we are ok
-		// => consider not reporting this as an error
-		// (in a real forward declaration, the corresponding objects are not in a scope
-		// and have incorrect pnolev)
-		if typ.elt.form == Type.FORWARD {
-			P.Error(obj.pos, `"` + obj.ident + `" is not declared after forward declaration`);
-		}
-	}
-}
-
-
-func (P *Parser) MarkExports() {
-	scope := P.top_scope;
-	for p := P.exports.first; p != nil; p = p.next {
-		obj := scope.Lookup(p.str);
-		if obj != nil {
-			obj.exported = true;
-			// For now we export deep
-			// TODO this should change eventually - we need selective export
-			if obj.kind == Object.TYPE {
-				typ := obj.typ;
-				if typ.form == Type.STRUCT || typ.form == Type.INTERFACE {
-					scope := typ.scope;
-					for p := scope.entries.first; p != nil; p = p.next {
-						p.obj.exported = true;
-					}
-				}
-			}
-		} else {
-			// TODO need to report proper src position
-			P.Error(-1, `"` + p.str + `" is not declared - cannot be exported`);
-		}
-	}
-}
-
-
-func (P *Parser) ParseProgram() {
-	P.Trace("Program");
-
-	P.OpenScope();
-	P.Expect(Scanner.PACKAGE);
-	obj := P.ParseIdentDecl(Object.PACKAGE);
-	P.Optional(Scanner.SEMICOLON);
-
-	{	P.OpenScope();
-		if P.level != 0 {
-			panic("incorrect scope level");
-		}
-
-		P.comp.Insert(Globals.NewPackage(P.scanner.filename, obj, P.top_scope));
-		if P.comp.pkg_ref != 1 {
-			panic("should have exactly one package now");
-		}
-
-		if P.comp.flags.sixg {
-			// automatically import package sys
-			pkg := P.comp.env.Import(P.comp, "sys");
-			if pkg != nil {
-				pno := pkg.obj.pnolev;  // preserve pno
-				P.Declare(pkg.obj);  // this changes pkg.obj.pnolev!
-				pkg.obj.pnolev = pno;  // reset pno
-			} else {
-				P.Error(P.pos, `pre-import of package "sys" failed`);
-			}
-		}
-
-		for P.tok == Scanner.IMPORT {
-			P.ParseDecl(false, Scanner.IMPORT);
-			P.Optional(Scanner.SEMICOLON);
-		}
-
-		for P.tok != Scanner.EOF {
-			P.ParseDeclaration();
-			P.Optional(Scanner.SEMICOLON);
-		}
-
-		P.ResolveForwardTypes();
-		P.MarkExports();
-
-		if P.level != 0 {
-			panic("incorrect scope level");
-		}
-		P.CloseScope();
-	}
-
-	P.CloseScope();
-	P.Ecart();
-}
diff --git a/usr/gri/gosrc/platform.go b/usr/gri/gosrc/platform.go
deleted file mode 100644
index 0e1c09a..0000000
--- a/usr/gri/gosrc/platform.go
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Platform
-
-import Utils "utils"
-
-
-// ----------------------------------------------------------------------------
-// Environment
-
-var
-	GOARCH,
-	GOOS,
-	GOROOT,
-	USER string;
-
-
-func GetEnv(key string) string {
-	n := len(key);
-	for i := 0; i < sys.envc(); i++ {
-		v := sys.envv(i);
-		if n < len(v) && v[0 : n] == key && v[n] == '=' {
-			return v[n + 1 : len(v)];  // +1: trim "="
-		}
-	}
-	return "";
-}
-
-
-func init() {
-	GOARCH = GetEnv("GOARCH");
-	GOOS = GetEnv("GOOS");
-	GOROOT = GetEnv("GOROOT");
-	USER = GetEnv("USER");
-}
-
-
-// ----------------------------------------------------------------------------
-// I/O
-
-const (
-	MAGIC_obj_file = "@gri-go.7@v0";  // make it clear thar it cannot be a source file
-	src_file_ext = ".go";
-	obj_file_ext = ".7";
-)
-
-
-func ReadObjectFile(filename string) (data string, ok bool) {
-	data, ok = sys.readfile(filename + obj_file_ext);
-	magic := MAGIC_obj_file;  // TODO remove once len(constant) works
-	if ok && len(data) >= len(magic) && data[0 : len(magic)] == magic {
-		return data, ok;
-	}
-	return "", false;
-}
-
-
-func ReadSourceFile(name string) (data string, ok bool) {
-	name = Utils.TrimExt(name, src_file_ext) + src_file_ext;
-	data, ok = sys.readfile(name);
-	return data, ok;
-}
-
-
-func WriteObjectFile(name string, data string) bool {
-	name = Utils.TrimExt(Utils.BaseName(name), src_file_ext) + obj_file_ext;
-	return sys.writefile(name, data);
-}
diff --git a/usr/gri/gosrc/printer.go b/usr/gri/gosrc/printer.go
deleted file mode 100755
index ce5f5f6..0000000
--- a/usr/gri/gosrc/printer.go
+++ /dev/null
@@ -1,285 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Printer
-
-import Globals "globals"
-import Object "object"
-import Type "type"
-import Universe "universe"
-
-
-type Printer struct {
-	comp *Globals.Compilation;
-	print_all bool;
-	level int;
-};
-
-
-func (P *Printer) PrintObjectStruct(obj *Globals.Object);
-func (P *Printer) PrintObject(obj *Globals.Object);
-
-func (P *Printer) PrintTypeStruct(typ *Globals.Type);
-func (P *Printer) PrintType(typ *Globals.Type);
-
-
-
-func (P *Printer) Init(comp *Globals.Compilation, print_all bool) {
-	P.comp = comp;
-	P.print_all = print_all;
-	P.level = 0;
-}
-
-
-func IsAnonymous(name string) bool {
-	return len(name) == 0 || name[0] == '.';
-}
-
-
-func (P *Printer) PrintSigRange(typ *Globals.Type, a, b int) {
-	scope := typ.scope;
-	if a + 1 == b && IsAnonymous(scope.entries.ObjAt(a).ident) {
-		P.PrintType(scope.entries.ObjAt(a).typ);  // result type only
-	} else {
-		print("(");
-		for i := a; i < b; i++ {
-			par := scope.entries.ObjAt(i);
-			if i > a {
-				print(", ");
-			}
-			print(par.ident, " ");
-			P.PrintType(par.typ);
-		}
-		print(")");
-	}
-}
-
-
-func (P *Printer) PrintSignature(typ *Globals.Type, fun *Globals.Object) {
-	p0 := 0;
-	if typ.form == Type.METHOD {
-		p0 = 1;
-	} else {
-		if typ.form != Type.FUNCTION {
-			panic("not a function or method");
-		}
-	}
-	r0 := p0 + typ.len;
-	l0 := typ.scope.entries.len;
-
-	if P.level == 0 {
-		print("func ");
-
-		if 0 < p0 {
-			P.PrintSigRange(typ, 0, p0);
-			print(" ");
-		}
-	}
-
-	if fun != nil {
-		P.PrintObject(fun);
-		//print(" ");
-	} else if p0 > 0 {
-		print(". ");
-	}
-
-	P.PrintSigRange(typ, p0, r0);
-
-	if r0 < l0 {
-		print(" ");
-		P.PrintSigRange(typ, r0, l0);
-	}
-}
-
-
-func (P *Printer) PrintIndent() {
-	print("\n");
-	for i := P.level; i > 0; i-- {
-		print("\t");
-	}
-}
-
-
-func (P *Printer) PrintScope(scope *Globals.Scope, delta int) {
-	// determine the number of scope entries to print
-	var n int;
-	if P.print_all {
-		n = scope.entries.len;
-	} else {
-		n = 0;
-		for p := scope.entries.first; p != nil; p = p.next {
-			if p.obj.exported && !IsAnonymous(p.obj.ident) {
-				n++;
-			}
-		}
-	}
-
-	// print the scope
-	const scale = 2;
-	if n > 0 {
-		P.level += delta;
-		for p := scope.entries.first; p != nil; p = p.next {
-			if P.print_all || p.obj.exported && !IsAnonymous(p.obj.ident) {
-				P.PrintIndent();
-				P.PrintObjectStruct(p.obj);
-			}
-		}
-		P.level -= delta;
-		P.PrintIndent();
-	}
-}
-
-
-func (P *Printer) PrintObjectStruct(obj *Globals.Object) {
-	switch obj.kind {
-	case Object.BAD:
-		P.PrintObject(obj);
-		print(" /* bad */");
-
-	case Object.CONST:
-		print("const ");
-		P.PrintObject(obj);
-		print(" ");
-		P.PrintType(obj.typ);
-
-	case Object.TYPE:
-		print("type ");
-		P.PrintObject(obj);
-		print(" ");
-		P.PrintTypeStruct(obj.typ);
-
-	case Object.VAR:
-		print("var ");
-		fallthrough;
-
-	case Object.FIELD:
-		P.PrintObject(obj);
-		print(" ");
-		P.PrintType(obj.typ);
-
-	case Object.FUNC:
-		P.PrintSignature(obj.typ, obj);
-
-	case Object.BUILTIN:
-		P.PrintObject(obj);
-		print(" /* builtin */");
-
-	case Object.PACKAGE:
-		print("package ");
-		P.PrintObject(obj);
-		print(" ");
-		P.PrintScope(P.comp.pkg_list[obj.pnolev].scope, 0);
-
-	default:
-		panic("UNREACHABLE");
-	}
-
-	if P.level > 0 {
-		print(";");
-	}
-}
-
-
-func (P *Printer) PrintObject(obj *Globals.Object) {
-	if obj.pnolev > 0 {
-		pkg := P.comp.pkg_list[obj.pnolev];
-		if pkg.key == "" {
-			// forward-declared package
-			print(`"`, pkg.file_name, `"`);
-		} else {
-			// imported package
-			print(pkg.obj.ident);
-		}
-		print(".");
-	}
-	print(obj.ident);
-}
-
-
-func (P *Printer) PrintTypeStruct(typ *Globals.Type) {
-	switch typ.form {
-	case Type.VOID:
-		print("void");
-
-	case Type.BAD:
-		print("<bad type>");
-
-	case Type.FORWARD:
-		print("<forward type>");
-
-	case Type.TUPLE:
-		print("<tuple type>");
-
-	case Type.NIL, Type.BOOL, Type.UINT, Type.INT, Type.FLOAT, Type.STRING, Type.ANY:
-		if typ.obj == nil {
-			panic("typ.obj == nil");
-		}
-		P.PrintType(typ);
-
-	case Type.ALIAS:
-		P.PrintType(typ.elt);
-		if typ.key != typ.elt {
-			print(" /* ");
-			P.PrintType(typ.key);
-			print(" */");
-		}
-
-	case Type.ARRAY:
-		print("[]");
-		P.PrintType(typ.elt);
-
-	case Type.STRUCT:
-		print("struct {");
-		P.PrintScope(typ.scope, 1);
-		print("}");
-
-	case Type.INTERFACE:
-		print("interface {");
-		P.PrintScope(typ.scope, 1);
-		print("}");
-
-	case Type.MAP:
-		print("map [");
-		P.PrintType(typ.key);
-		print("] ");
-		P.PrintType(typ.elt);
-
-	case Type.CHANNEL:
-		switch typ.aux {
-		case Type.SEND: print("chan <- ");
-		case Type.RECV: print("<- chan ");
-		case Type.SEND + Type.RECV: print("chan ");
-		default: panic("UNREACHABLE");
-		}
-		P.PrintType(typ.elt);
-
-	case Type.FUNCTION:
-		P.PrintSignature(typ, nil);
-
-	case Type.POINTER:
-		print("*");
-		P.PrintType(typ.elt);
-
-	default:
-		panic("UNREACHABLE");
-
-	}
-}
-
-
-func (P *Printer) PrintType(typ *Globals.Type) {
-	if typ.obj != nil {
-		P.PrintObject(typ.obj);
-	} else {
-		P.PrintTypeStruct(typ);
-	}
-}
-
-
-func PrintObject(comp *Globals.Compilation, obj *Globals.Object, print_all bool) {
-	var P Printer;
-	(&P).Init(comp, print_all);
-	(&P).PrintObjectStruct(obj);
-	print("\n");
-}
diff --git a/usr/gri/gosrc/scanner.go b/usr/gri/gosrc/scanner.go
deleted file mode 100644
index 158274e..0000000
--- a/usr/gri/gosrc/scanner.go
+++ /dev/null
@@ -1,785 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Scanner
-
-import Platform "platform"
-import Utils "utils"
-
-
-const (
-	ILLEGAL = iota;
-	EOF;
-	INT;
-	FLOAT;
-	STRING;
-
-	COMMA;
-	COLON;
-	SEMICOLON;
-	PERIOD;
-
-	LPAREN;
-	RPAREN;
-	LBRACK;
-	RBRACK;
-	LBRACE;
-	RBRACE;
-
-	ASSIGN;
-	DEFINE;
-
-	INC;
-	DEC;
-	NOT;
-
-	AND;
-	OR;
-	XOR;
-
-	ADD;
-	SUB;
-	MUL;
-	QUO;
-	REM;
-
-	EQL;
-	NEQ;
-	LSS;
-	LEQ;
-	GTR;
-	GEQ;
-
-	SHL;
-	SHR;
-
-	ARROW;
-
-	ADD_ASSIGN;
-	SUB_ASSIGN;
-	MUL_ASSIGN;
-	QUO_ASSIGN;
-	REM_ASSIGN;
-
-	AND_ASSIGN;
-	OR_ASSIGN;
-	XOR_ASSIGN;
-
-	SHL_ASSIGN;
-	SHR_ASSIGN;
-
-	LAND;
-	LOR;
-
-	// IDENT must be immediately before keywords
-	IDENT;
-
-	// keywords
-	KEYWORDS_BEG;
-	BREAK;
-	CASE;
-	CHAN;
-	CONST;
-	CONTINUE;
-	DEFAULT;
-	ELSE;
-	EXPORT;
-	FALLTHROUGH;
-	FOR;
-	FUNC;
-	GO;
-	GOTO;
-	IF;
-	IMPORT;
-	INTERFACE;
-	MAP;
-	PACKAGE;
-	RANGE;
-	RETURN;
-	SELECT;
-	STRUCT;
-	SWITCH;
-	TYPE;
-	VAR;
-	KEYWORDS_END;
-)
-
-
-var Keywords map [string] int;
-var VerboseMsgs bool;  // error message customization
-
-
-func TokenName(tok int) string {
-	switch (tok) {
-	case ILLEGAL: return "illegal";
-	case EOF: return "eof";
-	case INT: return "int";
-	case FLOAT: return "float";
-	case STRING: return "string";
-
-	case COMMA: return ",";
-	case COLON: return ":";
-	case SEMICOLON: return ";";
-	case PERIOD: return ".";
-
-	case LPAREN: return "(";
-	case RPAREN: return ")";
-	case LBRACK: return "[";
-	case RBRACK: return "]";
-	case LBRACE: return "LBRACE";
-	case RBRACE: return "RBRACE";
-
-	case ASSIGN: return "=";
-	case DEFINE: return ":=";
-
-	case INC: return "++";
-	case DEC: return "--";
-	case NOT: return "!";
-
-	case AND: return "&";
-	case OR: return "|";
-	case XOR: return "^";
-
-	case ADD: return "+";
-	case SUB: return "-";
-	case MUL: return "*";
-	case QUO: return "/";
-	case REM: return "%";
-
-	case EQL: return "==";
-	case NEQ: return "!=";
-	case LSS: return "<";
-	case LEQ: return "<=";
-	case GTR: return ">";
-	case GEQ: return ">=";
-
-	case SHL: return "<<";
-	case SHR: return ">>";
-
-	case ARROW: return "<-";
-
-	case ADD_ASSIGN: return "+=";
-	case SUB_ASSIGN: return "-=";
-	case MUL_ASSIGN: return "+=";
-	case QUO_ASSIGN: return "/=";
-	case REM_ASSIGN: return "%=";
-
-	case AND_ASSIGN: return "&=";
-	case OR_ASSIGN: return "|=";
-	case XOR_ASSIGN: return "^=";
-
-	case SHL_ASSIGN: return "<<=";
-	case SHR_ASSIGN: return ">>=";
-
-	case LAND: return "&&";
-	case LOR: return "||";
-
-	case IDENT: return "ident";
-
-	case BREAK: return "break";
-	case CASE: return "case";
-	case CHAN: return "chan";
-	case CONST: return "const";
-	case CONTINUE: return "continue";
-	case DEFAULT: return "default";
-	case ELSE: return "else";
-	case EXPORT: return "export";
-	case FALLTHROUGH: return "fallthrough";
-	case FOR: return "for";
-	case FUNC: return "func";
-	case GO: return "go";
-	case GOTO: return "goto";
-	case IF: return "if";
-	case IMPORT: return "import";
-	case INTERFACE: return "interface";
-	case MAP: return "map";
-	case PACKAGE: return "package";
-	case RANGE: return "range";
-	case RETURN: return "return";
-	case SELECT: return "select";
-	case STRUCT: return "struct";
-	case SWITCH: return "switch";
-	case TYPE: return "type";
-	case VAR: return "var";
-	}
-
-	return "???";
-}
-
-
-func init() {
-	Keywords = make(map [string] int);
-
-	for i := KEYWORDS_BEG; i <= KEYWORDS_END; i++ {
-	  Keywords[TokenName(i)] = i;
-	}
-
-	// Provide column information in error messages for gri only...
-	VerboseMsgs = Platform.USER == "gri";
-}
-
-
-func is_whitespace(ch int) bool {
-	return ch == ' ' || ch == '\r' || ch == '\n' || ch == '\t';
-}
-
-
-func is_letter(ch int) bool {
-	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= 128 ;
-}
-
-
-func digit_val(ch int) int {
-	if '0' <= ch && ch <= '9' {
-		return ch - '0';
-	}
-	if 'a' <= ch && ch <= 'f' {
-		return ch - 'a' + 10;
-	}
-	if 'A' <= ch && ch <= 'F' {
-		return ch - 'A' + 10;
-	}
-	return 16;  // larger than any legal digit val
-}
-
-
-type Scanner struct {
-	filename string;  // error reporting only
-	nerrors int;  // number of errors
-	errpos int;  // last error position
-
-	src string;  // scanned source
-	pos int;  // current reading position
-	ch int;  // one char look-ahead
-	chpos int;  // position of ch
-}
-
-
-// Read the next Unicode char into S.ch.
-// S.ch < 0 means end-of-file.
-//
-func (S *Scanner) Next() {
-	const (
-		Bit1 = 7;
-		Bitx = 6;
-		Bit2 = 5;
-		Bit3 = 4;
-		Bit4 = 3;
-
-		T1 = (1 << (Bit1 + 1) - 1) ^ 0xFF;  // 0000 0000
-		Tx = (1 << (Bitx + 1) - 1) ^ 0xFF;  // 1000 0000
-		T2 = (1 << (Bit2 + 1) - 1) ^ 0xFF;  // 1100 0000
-		T3 = (1 << (Bit3 + 1) - 1) ^ 0xFF;  // 1110 0000
-		T4 = (1 << (Bit4 + 1) - 1) ^ 0xFF;  // 1111 0000
-
-		Rune1 = 1 << (Bit1 + 0*Bitx) - 1;  // 0000 0000 0111 1111
-		Rune2 = 1 << (Bit2 + 1*Bitx) - 1;  // 0000 0111 1111 1111
-		Rune3 = 1 << (Bit3 + 2*Bitx) - 1;  // 1111 1111 1111 1111
-
-		Maskx = 0x3F;  // 1 << Bitx - 1;  // 0011 1111
-		Testx = 0xC0;  // Maskx ^ 0xFF;  // 1100 0000
-
-		Bad	= 0xFFFD;  // Runeerror
-	);
-
-	src := S.src;
-	lim := len(src);
-	pos := S.pos;
-
-	// 1-byte sequence
-	// 0000-007F => T1
-	if pos >= lim {
-		S.ch = -1;  // end of file
-		S.chpos = lim;
-		return;
-	}
-	c0 := int(src[pos]);
-	pos++;
-	if c0 < Tx {
-		S.ch = c0;
-		S.chpos = S.pos;
-		S.pos = pos;
-		return;
-	}
-
-	// 2-byte sequence
-	// 0080-07FF => T2 Tx
-	if pos >= lim {
-		goto bad;
-	}
-	c1 := int(src[pos]) ^ Tx;
-	pos++;
-	if c1 & Testx != 0 {
-		goto bad;
-	}
-	if c0 < T3 {
-		if c0 < T2 {
-			goto bad;
-		}
-		r := (c0 << Bitx | c1) & Rune2;
-		if  r <= Rune1 {
-			goto bad;
-		}
-		S.ch = r;
-		S.chpos = S.pos;
-		S.pos = pos;
-		return;
-	}
-
-	// 3-byte sequence
-	// 0800-FFFF => T3 Tx Tx
-	if pos >= lim {
-		goto bad;
-	}
-	c2 := int(src[pos]) ^ Tx;
-	pos++;
-	if c2 & Testx != 0 {
-		goto bad;
-	}
-	if c0 < T4 {
-		r := (((c0 << Bitx | c1) << Bitx) | c2) & Rune3;
-		if r <= Rune2 {
-			goto bad;
-		}
-		S.ch = r;
-		S.chpos = S.pos;
-		S.pos = pos;
-		return;
-	}
-
-	// bad encoding
-bad:
-	S.ch = Bad;
-	S.chpos = S.pos;
-	S.pos += 1;
-	return;
-}
-
-
-// Compute (line, column) information for a given source position.
-func (S *Scanner) LineCol(pos int) (line, col int) {
-	line = 1;
-	lpos := 0;
-
-	src := S.src;
-	if pos > len(src) {
-		pos = len(src);
-	}
-
-	for i := 0; i < pos; i++ {
-		if src[i] == '\n' {
-			line++;
-			lpos = i;
-		}
-	}
-
-	return line, pos - lpos;
-}
-
-
-func (S *Scanner) Error(pos int, msg string) {
-	const errdist = 10;
-	delta := pos - S.errpos;  // may be negative!
-	if delta < 0 {
-		delta = -delta;
-	}
-	if delta > errdist || S.nerrors == 0 /* always report first error */ {
-		print(S.filename);
-		if pos >= 0 {
-			// print position
-			line, col := S.LineCol(pos);
-			if VerboseMsgs {
-				print(":", line, ":", col);
-			} else {
-				print(":", line);
-			}
-		}
-		print(": ", msg, "\n");
-		S.nerrors++;
-		S.errpos = pos;
-	}
-
-	if S.nerrors >= 10 {
-		sys.Exit(1);
-	}
-}
-
-
-func (S *Scanner) Open(filename, src string) {
-	S.filename = filename;
-	S.nerrors = 0;
-	S.errpos = 0;
-
-	S.src = src;
-	S.pos = 0;
-	S.Next();
-}
-
-
-func CharString(ch int) string {
-	s := string(ch);
-	switch ch {
-	case '\a': s = `\a`;
-	case '\b': s = `\b`;
-	case '\f': s = `\f`;
-	case '\n': s = `\n`;
-	case '\r': s = `\r`;
-	case '\t': s = `\t`;
-	case '\v': s = `\v`;
-	case '\\': s = `\\`;
-	case '\'': s = `\'`;
-	}
-	return "'" + s + "' (U+" + Utils.IntToString(ch, 16) + ")";
-}
-
-
-func (S *Scanner) Expect(ch int) {
-	if S.ch != ch {
-		S.Error(S.chpos, "expected " + CharString(ch) + ", found " + CharString(S.ch));
-	}
-	S.Next();  // make always progress
-}
-
-
-func (S *Scanner) SkipWhitespace() {
-	for is_whitespace(S.ch) {
-		S.Next();
-	}
-}
-
-
-func (S *Scanner) SkipComment() {
-	// '/' already consumed
-	if S.ch == '/' {
-		// comment
-		S.Next();
-		for S.ch != '\n' && S.ch >= 0 {
-			S.Next();
-		}
-
-	} else {
-		/* comment */
-		pos := S.chpos - 1;
-		S.Expect('*');
-		for S.ch >= 0 {
-			ch := S.ch;
-			S.Next();
-			if ch == '*' && S.ch == '/' {
-				S.Next();
-				return;
-			}
-		}
-		S.Error(pos, "comment not terminated");
-	}
-}
-
-
-func (S *Scanner) ScanIdentifier() (tok int, val string) {
-	pos := S.chpos;
-	for is_letter(S.ch) || digit_val(S.ch) < 10 {
-		S.Next();
-	}
-	val = S.src[pos : S.chpos];
-
-	var present bool;
-	tok, present = Keywords[val];
-	if !present {
-		tok = IDENT;
-	}
-
-	return tok, val;
-}
-
-
-func (S *Scanner) ScanMantissa(base int) {
-	for digit_val(S.ch) < base {
-		S.Next();
-	}
-}
-
-
-func (S *Scanner) ScanNumber(seen_decimal_point bool) (tok int, val string) {
-	pos := S.chpos;
-	tok = INT;
-
-	if seen_decimal_point {
-		tok = FLOAT;
-		pos--;  // '.' is one byte
-		S.ScanMantissa(10);
-		goto exponent;
-	}
-
-	if S.ch == '0' {
-		// int or float
-		S.Next();
-		if S.ch == 'x' || S.ch == 'X' {
-			// hexadecimal int
-			S.Next();
-			S.ScanMantissa(16);
-		} else {
-			// octal int or float
-			S.ScanMantissa(8);
-			if digit_val(S.ch) < 10 || S.ch == '.' || S.ch == 'e' || S.ch == 'E' {
-				// float
-				tok = FLOAT;
-				goto mantissa;
-			}
-			// octal int
-		}
-		goto exit;
-	}
-
-mantissa:
-	// decimal int or float
-	S.ScanMantissa(10);
-
-	if S.ch == '.' {
-		// float
-		tok = FLOAT;
-		S.Next();
-		S.ScanMantissa(10)
-	}
-
-exponent:
-	if S.ch == 'e' || S.ch == 'E' {
-		// float
-		tok = FLOAT;
-		S.Next();
-		if S.ch == '-' || S.ch == '+' {
-			S.Next();
-		}
-		S.ScanMantissa(10);
-	}
-
-exit:
-	return tok, S.src[pos : S.chpos];
-}
-
-
-func (S *Scanner) ScanDigits(n int, base int) {
-	for digit_val(S.ch) < base {
-		S.Next();
-		n--;
-	}
-	if n > 0 {
-		S.Error(S.chpos, "illegal char escape");
-	}
-}
-
-
-func (S *Scanner) ScanEscape(quote int) string {
-	// TODO: fix this routine
-
-	ch := S.ch;
-	pos := S.chpos;
-	S.Next();
-	switch (ch) {
-	case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\':
-		return string(ch);
-
-	case '0', '1', '2', '3', '4', '5', '6', '7':
-		S.ScanDigits(3 - 1, 8);  // 1 char already read
-		return "";  // TODO fix this
-
-	case 'x':
-		S.ScanDigits(2, 16);
-		return "";  // TODO fix this
-
-	case 'u':
-		S.ScanDigits(4, 16);
-		return "";  // TODO fix this
-
-	case 'U':
-		S.ScanDigits(8, 16);
-		return "";  // TODO fix this
-
-	default:
-		// check for quote outside the switch for better generated code (eventually)
-		if ch == quote {
-			return string(quote);
-		}
-		S.Error(pos, "illegal char escape");
-	}
-
-	return "";  // TODO fix this
-}
-
-
-func (S *Scanner) ScanChar() string {
-	// '\'' already consumed
-
-	pos := S.chpos - 1;
-	ch := S.ch;
-	S.Next();
-	if ch == '\\' {
-		S.ScanEscape('\'');
-	}
-
-	S.Expect('\'');
-	return S.src[pos : S.chpos];
-}
-
-
-func (S *Scanner) ScanString() string {
-	// '"' already consumed
-
-	pos := S.chpos - 1;
-	for S.ch != '"' {
-		ch := S.ch;
-		S.Next();
-		if ch == '\n' || ch < 0 {
-			S.Error(pos, "string not terminated");
-			break;
-		}
-		if ch == '\\' {
-			S.ScanEscape('"');
-		}
-	}
-
-	S.Next();
-	return S.src[pos : S.chpos];
-}
-
-
-func (S *Scanner) ScanRawString() string {
-	// '`' already consumed
-
-	pos := S.chpos - 1;
-	for S.ch != '`' {
-		ch := S.ch;
-		S.Next();
-		if ch == '\n' || ch < 0 {
-			S.Error(pos, "string not terminated");
-			break;
-		}
-	}
-
-	S.Next();
-	return S.src[pos : S.chpos];
-}
-
-
-func (S *Scanner) Select2(tok0, tok1 int) int {
-	if S.ch == '=' {
-		S.Next();
-		return tok1;
-	}
-	return tok0;
-}
-
-
-func (S *Scanner) Select3(tok0, tok1, ch2, tok2 int) int {
-	if S.ch == '=' {
-		S.Next();
-		return tok1;
-	}
-	if S.ch == ch2 {
-		S.Next();
-		return tok2;
-	}
-	return tok0;
-}
-
-
-func (S *Scanner) Select4(tok0, tok1, ch2, tok2, tok3 int) int {
-	if S.ch == '=' {
-		S.Next();
-		return tok1;
-	}
-	if S.ch == ch2 {
-		S.Next();
-		if S.ch == '=' {
-			S.Next();
-			return tok3;
-		}
-		return tok2;
-	}
-	return tok0;
-}
-
-
-func (S *Scanner) Scan() (tok, pos int, val string) {
-	S.SkipWhitespace();
-
-	ch := S.ch;
-	tok = ILLEGAL;
-	pos = S.chpos;
-
-	switch {
-	case is_letter(ch): tok, val = S.ScanIdentifier();
-	case digit_val(ch) < 10: tok, val = S.ScanNumber(false);
-	default:
-		S.Next();  // always make progress
-		switch ch {
-		case -1: tok = EOF;
-		case '"': tok, val = STRING, S.ScanString();
-		case '\'': tok, val = INT, S.ScanChar();
-		case '`': tok, val = STRING, S.ScanRawString();
-		case ':': tok = S.Select2(COLON, DEFINE);
-		case '.':
-			if digit_val(S.ch) < 10 {
-				tok, val = S.ScanNumber(true);
-			} else {
-				tok = PERIOD;
-			}
-		case ',': tok = COMMA;
-		case ';': tok = SEMICOLON;
-		case '(': tok = LPAREN;
-		case ')': tok = RPAREN;
-		case '[': tok = LBRACK;
-		case ']': tok = RBRACK;
-		case '{': tok = LBRACE;
-		case '}': tok = RBRACE;
-		case '+': tok = S.Select3(ADD, ADD_ASSIGN, '+', INC);
-		case '-': tok = S.Select3(SUB, SUB_ASSIGN, '-', DEC);
-		case '*': tok = S.Select2(MUL, MUL_ASSIGN);
-		case '/':
-			if S.ch == '/' || S.ch == '*' {
-				S.SkipComment();
-				// cannot simply return because of 6g bug
-				tok, pos, val = S.Scan();
-				return tok, pos, val;
-			}
-			tok = S.Select2(QUO, QUO_ASSIGN);
-		case '%': tok = S.Select2(REM, REM_ASSIGN);
-		case '^': tok = S.Select2(XOR, XOR_ASSIGN);
-		case '<':
-			if S.ch == '-' {
-				S.Next();
-				tok = ARROW;
-			} else {
-				tok = S.Select4(LSS, LEQ, '<', SHL, SHL_ASSIGN);
-			}
-		case '>': tok = S.Select4(GTR, GEQ, '>', SHR, SHR_ASSIGN);
-		case '=': tok = S.Select2(ASSIGN, EQL);
-		case '!': tok = S.Select2(NOT, NEQ);
-		case '&': tok = S.Select3(AND, AND_ASSIGN, '&', LAND);
-		case '|': tok = S.Select3(OR, OR_ASSIGN, '|', LOR);
-		default:
-			S.Error(pos, "illegal character " + CharString(ch));
-			tok = ILLEGAL;
-		}
-	}
-
-	return tok, pos, val;
-}
-
-
-type Token struct {
-	pos int;
-	tok int;
-	val string;
-}
-
-
-func (S *Scanner) Server(c chan *Token) {
-	for {
-		t := new(Token);
-		t.tok, t.pos, t.val = S.Scan();
-		c <- t;
-		if t.tok == EOF {
-			break;
-		}
-	}
-}
diff --git a/usr/gri/gosrc/test_scanner.go b/usr/gri/gosrc/test_scanner.go
deleted file mode 100644
index 8fa8212..0000000
--- a/usr/gri/gosrc/test_scanner.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import Scanner "scanner"
-
-
-func Scan1(filename, src string) {
-	S := new(Scanner.Scanner);
-	S.Open(filename, src);
-	for {
-		tok, pos, val := S.Scan();
-		print(pos, ": ", Scanner.TokenName(tok));
-		if tok == Scanner.IDENT || tok == Scanner.INT || tok == Scanner.FLOAT || tok == Scanner.STRING {
-			print(" ", val);
-		}
-		print("\n");
-		if tok == Scanner.EOF {
-			return;
-		}
-	}
-}
-
-
-func Scan2(filename, src string) {
-	S := new(Scanner.Scanner);
-	S.Open(filename, src);
-	c := make(chan *Scanner.Token, 32);
-	go S.Server(c);
-	for {
-		var t *Scanner.Token;
-		t = <- c;
-		tok, pos, val := t.tok, t.pos, t.val;
-		print(pos, ": ", Scanner.TokenName(tok));
-		if tok == Scanner.IDENT || tok == Scanner.INT || tok == Scanner.FLOAT || tok == Scanner.STRING {
-			print(" ", val);
-		}
-		print("\n");
-		if tok == Scanner.EOF {
-			return;
-		}
-	}
-}
-
-
-func main() {
-	for i := 1; i < len(sys.Args); i++ {
-		var src string;
-		var ok bool;
-		src, ok = sys.readfile(sys.Args[i]);
-		if ok {
-			print("scanning (standard) " + sys.Args[i] + "\n");
-			Scan1(sys.Args[i], src);
-			print("\n");
-			print("scanning (channels) " + sys.Args[i] + "\n");
-			Scan2(sys.Args[i], src);
-		} else {
-			print("error: cannot read " + sys.Args[i] + "\n");
-		}
-		print("\n");
-	}
-}
diff --git a/usr/gri/gosrc/type.go b/usr/gri/gosrc/type.go
deleted file mode 100644
index ad940dc..0000000
--- a/usr/gri/gosrc/type.go
+++ /dev/null
@@ -1,204 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Type
-
-import Globals "globals"
-import Object "object"
-
-
-const /* form */ (
-	// internal types
-	// We should never see one of these.
-	UNDEF = iota;
-
-	// VOID types are used when we don't have a type. Never exported.
-	// (exported type forms must be > 0)
-	VOID;
-
-	// BAD types are compatible with any type and don't cause further errors.
-	// They are introduced only as a result of an error in the source code. A
-	// correct program cannot have BAD types.
-	BAD;
-
-	// FORWARD types are forward-declared (incomplete) types. They can only
-	// be used as element types of pointer types and must be resolved before
-	// their internals are accessible.
-	FORWARD;
-
-	// TUPLE types represent multi-valued result types of functions and
-	// methods.
-	TUPLE;
-
-	// The type of nil.
-	NIL;
-
-	// basic types
-	BOOL; UINT; INT; FLOAT; STRING; INTEGER;
-
-	// 'any' type  // TODO this should go away eventually
-	ANY;
-
-	// composite types
-	ALIAS; ARRAY; STRUCT; INTERFACE; MAP; CHANNEL; FUNCTION; METHOD; POINTER;
-)
-
-
-const /* Type.aux */ (
-	SEND = 1;  // chan>
-	RECV = 2;  // chan<
-)
-
-
-// The 'Type' declaration should be here as well, but 6g cannot handle
-// this due to cross-package circular references. For now it's all in
-// globals.go.
-
-
-func FormStr(form int) string {
-	switch form {
-	case VOID: return "VOID";
-	case BAD: return "BAD";
-	case FORWARD: return "FORWARD";
-	case TUPLE: return "TUPLE";
-	case NIL: return "NIL";
-	case BOOL: return "BOOL";
-	case UINT: return "UINT";
-	case INT: return "INT";
-	case FLOAT: return "FLOAT";
-	case STRING: return "STRING";
-	case ANY: return "ANY";
-	case ALIAS: return "ALIAS";
-	case ARRAY: return "ARRAY";
-	case STRUCT: return "STRUCT";
-	case INTERFACE: return "INTERFACE";
-	case MAP: return "MAP";
-	case CHANNEL: return "CHANNEL";
-	case FUNCTION: return "FUNCTION";
-	case METHOD: return "METHOD";
-	case POINTER: return "POINTER";
-	}
-	return "<unknown Type form>";
-}
-
-
-func Equal(x, y *Globals.Type) bool;
-
-func Equal0(x, y *Globals.Type) bool {
-	if x == y {
-		return true;  // identical types are equal
-	}
-
-	if x.form == BAD || y.form == BAD {
-		return true;  // bad types are always equal (avoid excess error messages)
-	}
-
-	// TODO where to check for *T == nil ?
-	if x.form != y.form {
-		return false;  // types of different forms are not equal
-	}
-
-	switch x.form {
-	case FORWARD, BAD:
-		break;
-
-	case NIL, BOOL, STRING, ANY:
-		return true;
-
-	case UINT, INT, FLOAT:
-		return x.size == y.size;
-
-	case ARRAY:
-		return
-			x.len == y.len &&
-			Equal(x.elt, y.elt);
-
-	case MAP:
-		return
-			Equal(x.key, y.key) &&
-			Equal(x.elt, y.elt);
-
-	case CHANNEL:
-		return
-			x.aux == y.aux &&
-			Equal(x.elt, y.elt);
-
-	case FUNCTION, METHOD:
-		{	xp := x.scope.entries;
-			yp := x.scope.entries;
-			if	x.len != y.len &&  // number of parameters
-				xp.len != yp.len  // recv + parameters + results
-			{
-				return false;
-			}
-			for p, q := xp.first, yp.first; p != nil; p, q = p.next, q.next {
-				xf := p.obj;
-				yf := q.obj;
-				if xf.kind != Object.VAR || yf.kind != Object.VAR {
-					panic("parameters must be vars");
-				}
-				if !Equal(xf.typ, yf.typ) {
-					return false;
-				}
-			}
-		}
-		return true;
-
-	case STRUCT:
-		/*
-		{	ObjList* xl = &x.scope.list;
-			ObjList* yl = &y.scope.list;
-			if xl.len() != yl.len() {
-				return false;  // scopes of different sizes are not equal
-			}
-			for int i = xl.len(); i-- > 0; {
-				Object* xf = (*xl)[i];
-				Object* yf = (*yl)[i];
-				ASSERT(xf.kind == Object.VAR && yf.kind == Object.VAR);
-				if xf.name != yf.name) || ! EqualTypes(xf.type(), yf.type() {
-					return false;
-				}
-			}
-		}
-		return true;
-		*/
-		// Scopes must be identical for them to be equal.
-		// If we reach here, they weren't.
-		return false;
-
-	case INTERFACE:
-		panic("UNIMPLEMENTED");
-		return false;
-
-	case POINTER:
-		return Equal(x.elt, y.elt);
-
-	case TUPLE:
-		panic("UNIMPLEMENTED");
-		return false;
-	}
-
-	panic("UNREACHABLE");
-	return false;
-}
-
-
-func Equal(x, y *Globals.Type) bool {
-	res := Equal0(x, y);
-	// TODO should do the check below only in debug mode
-	if Equal0(y, x) != res {
-		panic("type equality must be symmetric");
-	}
-	return res;
-}
-
-
-func Assigneable(from, to *Globals.Type) bool {
-	if Equal(from, to) {
-		return true;
-	}
-
-	panic("UNIMPLEMENTED");
-	return false;
-}
diff --git a/usr/gri/gosrc/universe.go b/usr/gri/gosrc/universe.go
deleted file mode 100755
index 95111fc..0000000
--- a/usr/gri/gosrc/universe.go
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Universe
-
-import Globals "globals"
-import Object "object"
-import Type "type"
-
-
-var (
-	scope *Globals.Scope;
-	types *Globals.List;
-
-	// internal types
-	void_t,
-	bad_t,
-	nil_t,
-
-	// basic types
-	bool_t,
-	uint8_t,
-	uint16_t,
-	uint32_t,
-	uint64_t,
-	int8_t,
-	int16_t,
-	int32_t,
-	int64_t,
-	float32_t,
-	float64_t,
-	float80_t,
-	string_t,
-	integer_t,
-	any_t,
-
-	// alias types
-	byte_t,
-	ushort_t,
-	uint_t,
-	ulong_t,
-	short_t,
-	int_t,
-	long_t,
-	float_t,
-	double_t,
-	ptrint_t *Globals.Type;
-
-	true_,
-	false_,
-	iota_,
-	nil_ *Globals.Object;
-)
-
-
-func DeclObj(kind int, ident string, typ *Globals.Type) *Globals.Object {
-	obj := Globals.NewObject(-1 /* no source pos */, kind, ident);
-	obj.typ = typ;
-	if kind == Object.TYPE && typ.obj == nil {
-		typ.obj = obj;  // set primary type object
-	}
-	scope.Insert(obj);
-	return obj
-}
-
-
-func DeclType(form int, ident string, size int) *Globals.Type {
-  typ := Globals.NewType(form);
-  typ.size = size;
-  return DeclObj(Object.TYPE, ident, typ).typ;
-}
-
-
-func DeclAlias(ident string, typ *Globals.Type) *Globals.Type {
-	alias := Globals.NewType(Type.ALIAS);
-	alias.key = typ;
-	alias.elt = typ;
-	return DeclObj(Object.TYPE, ident, alias).typ;
-}
-
-
-func Register(typ *Globals.Type) *Globals.Type {
-	if types.len < 0 {
-		panic("types.len < 0");
-	}
-	typ.ref = types.len;
-	types.AddTyp(typ);
-	return typ;
-}
-
-
-func init() {
-	scope = Globals.NewScope(nil);  // universe has no parent
-	types = Globals.NewList();
-
-	// Interal types
-	void_t = Globals.NewType(Type.VOID);
-	Globals.Universe_void_t = void_t;
-	bad_t = Globals.NewType(Type.BAD);
-	nil_t = Globals.NewType(Type.NIL);
-
-	// Basic types
-	bool_t = Register(DeclType(Type.BOOL, "bool", 1));
-	uint8_t = Register(DeclType(Type.UINT, "uint8", 1));
-	uint16_t = Register(DeclType(Type.UINT, "uint16", 2));
-	uint32_t = Register(DeclType(Type.UINT, "uint32", 4));
-	uint64_t = Register(DeclType(Type.UINT, "uint64", 8));
-	int8_t = Register(DeclType(Type.INT, "int8", 1));
-	int16_t = Register(DeclType(Type.INT, "int16", 2));
-	int32_t = Register(DeclType(Type.INT, "int32", 4));
-	int64_t = Register(DeclType(Type.INT, "int64", 8));
-	float32_t = Register(DeclType(Type.FLOAT, "float32", 4));
-	float64_t = Register(DeclType(Type.FLOAT, "float64", 8));
-	float80_t = Register(DeclType(Type.FLOAT, "float80", 10));
-	string_t = Register(DeclType(Type.STRING, "string", 8));
-	integer_t = Register(DeclType(Type.INTEGER, "integer", 8));
-	any_t = Register(DeclType(Type.ANY, "any", 8));
-
-	// All but 'byte' should be platform-dependent, eventually.
-	byte_t = Register(DeclAlias("byte", uint8_t));
-	ushort_t = Register(DeclAlias("ushort", uint16_t));
-	uint_t = Register(DeclAlias("uint", uint32_t));
-	ulong_t = Register(DeclAlias("ulong", uint32_t));
-	short_t = Register(DeclAlias("short", int16_t));
-	int_t = Register(DeclAlias("int", int32_t));
-	long_t = Register(DeclAlias("long", int32_t));
-	float_t = Register(DeclAlias("float", float32_t));
-	double_t = Register(DeclAlias("double", float64_t));
-	ptrint_t = Register(DeclAlias("ptrint", uint64_t));
-
-	// Predeclared constants
-	true_ = DeclObj(Object.CONST, "true", bool_t);
-	false_ = DeclObj(Object.CONST, "false", bool_t);
-	iota_ = DeclObj(Object.CONST, "iota", int_t);
-	nil_ = DeclObj(Object.CONST, "nil", nil_t);
-
-	// Builtin functions
-	DeclObj(Object.BUILTIN, "len", void_t);
-	DeclObj(Object.BUILTIN, "new", void_t);
-	DeclObj(Object.BUILTIN, "panic", void_t);
-	DeclObj(Object.BUILTIN, "print", void_t);
-
-	// scope.Print();
-}
diff --git a/usr/gri/gosrc/utils.go b/usr/gri/gosrc/utils.go
deleted file mode 100644
index 57a8d32..0000000
--- a/usr/gri/gosrc/utils.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package Utils
-
-
-func BaseName(s string) string {
-	// TODO this is not correct for non-ASCII strings!
-	i := len(s) - 1;
-	for i >= 0 && s[i] != '/' {
-		if s[i] > 128 {
-			panic("non-ASCII string");
-		}
-		i--;
-	}
-	return s[i + 1 : len(s)];
-}
-
-
-func Contains(s, sub string, pos int) bool {
-	end := pos + len(sub);
-	return pos >= 0 && end <= len(s) && s[pos : end] == sub;
-}
-
-
-func TrimExt(s, ext string) string {
-	i := len(s) - len(ext);
-	if i >= 0 && s[i : len(s)] == ext {
-		s = s[0 : i];
-	}
-	return s;
-}
-
-
-func IntToString(x, base int) string {
-	x0 := x;
-	if x < 0 {
-		x = -x;
-		if x < 0 {
-			panic("smallest int not handled");
-		}
-	} else if x == 0 {
-		return "0";
-	}
-
-	// x > 0
-	hex := "0123456789ABCDEF";
-	var buf [32] byte;
-	i := len(buf);
-	for x > 0 {
-		i--;
-		buf[i] = hex[x % base];
-		x /= base;
-	}
-
-	if x0 < 0 {
-		i--;
-		buf[i] = '-';
-	}
-
-	return string(buf)[i : len(buf)];
-}
diff --git a/usr/gri/gosrc/verifier.go b/usr/gri/gosrc/verifier.go
deleted file mode 100644
index dbb5ffd..0000000
--- a/usr/gri/gosrc/verifier.go
+++ /dev/null
@@ -1,165 +0,0 @@
-// Copyright 2009 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Verifies compiler-internal data structures.
-
-package Verifier
-
-import Utils "utils"
-import Scanner "scanner"
-import Globals "globals"
-import Object "object"
-import Type "type"
-import Universe "universe"
-import Import "import"
-import AST "ast"
-
-
-func Error(msg string) {
-	panic("internal compiler error: ", msg, "\n");
-}
-
-
-type Verifier struct {
-	comp *Globals.Compilation;
-
-	// various sets for marking the graph (and thus avoid cycles)
-	objs map[*Globals.Object] bool;
-	typs map[*Globals.Type] bool;
-	pkgs map[*Globals.Package] bool;
-}
-
-
-func (V *Verifier) VerifyObject(obj *Globals.Object, pnolev int);
-
-
-func (V *Verifier) VerifyType(typ *Globals.Type) {
-	if present, ok := V.typs[typ]; present {
-		return;  // already verified
-	}
-	V.typs[typ] = true;
-
-	if typ.obj != nil {
-		V.VerifyObject(typ.obj, 0);
-	}
-
-	switch typ.form {
-	case Type.VOID:
-	case Type.BAD:
-		break;  // TODO for now - remove eventually
-
-	case Type.FORWARD:
-		if typ.scope == nil {
-			Error("forward types must have a scope");
-		}
-
-	case Type.TUPLE:
-		break;
-	case Type.NIL:
-		break;
-	case Type.BOOL:
-		break;
-	case Type.UINT:
-		break;
-	case Type.INT:
-		break;
-	case Type.FLOAT:
-		break;
-	case Type.STRING:
-		break;
-	case Type.ANY:
-		break;
-	case Type.ALIAS:
-		break;
-	case Type.ARRAY:
-		break;
-	case Type.STRUCT:
-		break;
-	case Type.INTERFACE:
-		break;
-	case Type.MAP:
-		break;
-	case Type.CHANNEL:
-		break;
-	case Type.FUNCTION:
-		break;
-	case Type.POINTER:
-		break;
-	default:
-		Error("illegal type form " + Type.FormStr(typ.form));
-	}
-}
-
-
-func (V *Verifier) VerifyObject(obj *Globals.Object, pnolev int) {
-	if present, ok := V.objs[obj]; present {
-		return;  // already verified
-	}
-	V.objs[obj] = true;
-
-	// all objects have a non-nil type
-	V.VerifyType(obj.typ);
-
-	switch obj.kind {
-	case Object.CONST:
-		break;
-	case Object.TYPE:
-		break;
-	case Object.VAR:
-		break;
-	case Object.FUNC:
-		break;
-	case Object.PACKAGE:
-		break;
-	case Object.LABEL:
-		break;
-	default:
-		Error("illegal object kind " + Object.KindStr(obj.kind));
-	}
-}
-
-
-func (V *Verifier) VerifyScope(scope *Globals.Scope) {
-	for p := scope.entries.first; p != nil; p = p.next {
-		V.VerifyObject(p.obj, 0);
-	}
-}
-
-
-func (V *Verifier) VerifyPackage(pkg *Globals.Package, pno int) {
-	if present, ok := V.pkgs[pkg]; present {
-		return;  // already verified
-	}
-	V.pkgs[pkg] = true;
-
-	V.VerifyObject(pkg.obj, pno);
-	V.VerifyScope(pkg.scope);
-}
-
-
-func (V *Verifier) Verify(comp *Globals.Compilation) {
-	// initialize Verifier
-	V.comp = comp;
-	V.objs = make(map[*Globals.Object] bool);
-	V.typs = make(map[*Globals.Type] bool);
-	V.pkgs = make(map[*Globals.Package] bool);
-
-	// verify all packages
-	filenames := make(map[string] bool);
-	for i := 0; i < comp.pkg_ref; i++ {
-		pkg := comp.pkg_list[i];
-		// each pkg filename must appear only once
-		if present, ok := filenames[pkg.file_name]; present {
-			Error("package filename present more than once");
-		}
-		filenames[pkg.file_name] = true;
-		V.VerifyPackage(pkg, i);
-	}
-}
-
-
-func Verify(comp *Globals.Compilation) {
-	V := new(Verifier);
-	V.Verify(comp);
-}