- make code in gosrc compile again, check in all pending changes

(this code doesn't match the existing language at this point,
  but it's a large code base which compiles - will eventually go
  away)
- enable compilation of it again in run.bash

R=r
DELTA=1147  (534 added, 311 deleted, 302 changed)
OCL=22176
CL=22176

src/run.bash

@@ -52,11 +52,11 @@ time make
 make smoketest
 ) || exit $?
 
-# (xcd ../usr/gri/gosrc
+(xcd ../usr/gri/gosrc
-# make clean
+make clean
-# time make
+time make
-# # make test
+# make test
-# ) || exit $?
+) || exit $?
 
 (xcd ../doc/progs
 time run

usr/gri/gosrc/ast.go

@@ -5,12 +5,26 @@
 package AST
 
 import Globals "globals"
+import GlobalObject "object"
+import Type "type"
 import Universe "universe"
 
 
 // ----------------------------------------------------------------------------
 // Expressions
 
+export const /* op */ (
+	LITERAL = iota;
+	OBJECT;
+	DEREF;
+	SELECT;
+	CALL;
+	TUPLE;
+)
+
+
+// ----------------------------------------------------------------------------
+// Literals
 
 export type Literal struct {
 	pos_ int;
@@ -22,18 +36,13 @@ export type Literal struct {
 }
 
 
-func (x *Literal) pos() int {
+func (x *Literal) op() int  { return LITERAL; }
-	return x.pos_;
+func (x *Literal) pos() int  { return x.pos_; }
-}
+func (x *Literal) typ() *Globals.Type  { return x.typ_; }
-
-
-func (x *Literal) typ() *Globals.Type {
-	return x.typ_;
-}
 
 
 export func NewLiteral(pos int, typ *Globals.Type) *Literal {
-	x := new(*Literal);
+	x := new(Literal);
 	x.pos_ = pos;
 	x.typ_ = typ;
 	return x;
@@ -43,6 +52,9 @@ export func NewLiteral(pos int, typ *Globals.Type) *Literal {
 export 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.
@@ -52,24 +64,43 @@ export type Object struct {
 }
 
 
-func (x *Object) pos() int {
+func (x *Object) op() int  { return OBJECT; }
-	return x.pos_;
+func (x *Object) pos() int  { return x.pos_; }
-}
+func (x *Object) typ() *Globals.Type  { return x.obj.typ; }
-
-
-func (x *Object) typ() *Globals.Type {
-	return x.obj.typ;
-}
 
 
 export func NewObject(pos int, obj* Globals.Object) *Object {
-	x := new(*Object);
+	x := new(Object);
 	x.pos_ = pos;
 	x.obj = obj;
 	return x;
 }
 
 
+// ----------------------------------------------------------------------------
+// Derefs
+
+// TODO model Deref as unary operation?
+export 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; }
+
+
+export func NewDeref(ptr Globals.Expr) *Deref {
+	x := new(Deref);
+	x.ptr_ = ptr;
+	return x;
+}
+
+
+// ----------------------------------------------------------------------------
+// Selectors
+
 // TODO model Selector as binary operation?
 export type Selector struct {
 	pos_ int;
@@ -77,39 +108,87 @@ export type Selector struct {
 }
 
 
-func (x *Selector) pos() int {
+func (x *Selector) op() int  { return SELECT; }
-	return x.pos_;
+func (x *Selector) pos() int  { return x.pos_; }
-}
+func (x *Selector) typ() *Globals.Type  { return x.typ_; }
-
-
-func (x *Selector) typ() *Globals.Type {
-	return x.typ_;
-}
 
 
 export func NewSelector(pos int, typ *Globals.Type) *Selector {
-	x := new(*Selector);
+	x := new(Selector);
 	x.pos_ = pos;
 	x.typ_ = typ;
 	return x;
 }
 
 
+// ----------------------------------------------------------------------------
+// Calls
+
+export 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; }
+
+
+export func NewCall(args *Globals.List) *Call {
+	x := new(Call);
+	x.args = args;
+	return x;
+}
+
+
+// ----------------------------------------------------------------------------
+// Binary expressions
+
 export type BinaryExpr struct {
+	op_ int;
 	pos_ int;
 	typ_ *Globals.Type;
-	op int;
 	x, y Globals.Expr;
 }
 
 
-func (x *BinaryExpr) pos() int {
+func (x *BinaryExpr) op() int  { return x.op_; }
-	return x.pos_;
+func (x *BinaryExpr) pos() int  { return x.pos_; }
+func (x *BinaryExpr) typ() *Globals.Type  {	return x.typ_; }
+
+
+// ----------------------------------------------------------------------------
+// Tuples
+
+export type Tuple struct {
+	typ_ *Globals.Type;
+	list *Globals.List;
 }
 
 
-func (x *BinaryExpr) typ() *Globals.Type {
+func (x *Tuple) op() int  {	return TUPLE; }
-	return x.typ_;
+func (x *Tuple) pos() int  { return x.list.first.expr.pos(); }
+func (x *Tuple) typ() *Globals.Type  { return x.typ_; }
+
+
+export 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;
 }
 
 

usr/gri/gosrc/compilation.go

@@ -19,6 +19,54 @@ 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;
+}
+
+
+export 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");
@@ -83,34 +131,38 @@ export func Export(comp *Globals.Compilation, pkg_file string) {
 
 
 export 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 := new(Scanner.Scanner);
 	scanner.Open(src_file, src);
 
 	var tstream chan *Scanner.Token;
 	if comp.flags.token_chan {
-		tstream = new(chan *Scanner.Token, 100);
+		tstream = make(chan *Scanner.Token, 100);
 		go scanner.Server(tstream);
 	}
 
-	parser := new(*Parser.Parser);
+	parser := new(Parser.Parser);
 	parser.Open(comp, scanner, tstream);
 
 	parser.ParseProgram();
-	if parser.S.nerrors > 0 {
+	if parser.scanner.nerrors > 0 {
-		return;
-	}
-
-	if !comp.flags.ast {
 		return;
 	}
 

usr/gri/gosrc/export.go

@@ -174,6 +174,9 @@ func (E *Exporter) WriteType(typ *Globals.Type) {
 	}
 	
 	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 != "" {
@@ -181,25 +184,29 @@ func (E *Exporter) WriteType(typ *Globals.Type) {
 		}
 		
 	case Type.ALIAS, Type.MAP:
-		E.WriteType(typ.aux);
+		E.WriteType(typ.key);
+		E.WriteType(typ.elt);
+
+	case Type.TUPLE:
 		E.WriteType(typ.elt);
 
 	case Type.ARRAY:
-		E.WriteInt(typ.len_);
+		E.WriteInt(typ.len);
 		E.WriteType(typ.elt);
 
 	case Type.CHANNEL:
-		E.WriteInt(typ.flags);
+		E.WriteInt(typ.aux);
 		E.WriteType(typ.elt);
 
-	case Type.FUNCTION:
+	case Type.FUNCTION, Type.METHOD:
-		E.WriteInt(typ.flags);
+		E.WriteInt(typ.len);
+		E.WriteType(typ.elt);
 		E.WriteScope(typ.scope);
 		
 	case Type.STRUCT, Type.INTERFACE:
 		E.WriteScope(typ.scope);
 
-	case Type.POINTER, Type.REFERENCE:
+	case Type.POINTER:
 		E.WriteType(typ.elt);
 
 	default:
@@ -266,7 +273,7 @@ func (E *Exporter) Export(comp* Globals.Compilation) string {
 			i++;
 		}
 	}
-	E.type_ref = Universe.types.len_;
+	E.type_ref = Universe.types.len;
 	
 	// export package 0
 	pkg := comp.pkg_list[0];

usr/gri/gosrc/expr.go

@@ -0,0 +1,164 @@
+// 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);
+}
+
+
+export 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;
+}
+
+
+export 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;
+}
+
+
+export func AssertType(comp *Globals.Compilation, x Globals.Expr, pos int, typ *Globals.Type) Globals.Expr {
+	return AST.Bad;
+}
+
+
+export 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;
+}
+
+
+export 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;
+}
+
+
+export 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;
+}
+
+
+export func UnaryExpr(comp *Globals.Compilation, x Globals.Expr) Globals.Expr {
+	return AST.Bad;
+}
+
+
+export 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;
+}

usr/gri/gosrc/globals.go

@@ -18,6 +18,11 @@ 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).
+
 export type Object struct {
 	exported bool;
 	pos int;  // source position (< 0 if unknown position)
@@ -31,12 +36,12 @@ export type Object struct {
 export type Type struct {
 	ref int;  // for exporting only: >= 0 means already exported
 	form int;
-	flags int;  // channels, functions
 	size int;  // in bytes
-	len_ int;  // array length, no. of parameters (w/o recv)
+	len int;  // array length, no. of function/method parameters (w/o recv)
+	aux int;  // channel info
 	obj *Object;  // primary type object or NULL
-	aux *Type;  // alias base type or map key
+	key *Type;  // alias base type or map key
-	elt *Type;  // aliases, arrays, maps, channels, pointers
+	elt *Type;  // aliased type, array, map, channel or pointer element type, function result type, tuple function type
 	scope *Scope;  // forwards, structs, interfaces, functions
 }
 
@@ -51,7 +56,7 @@ export type Package struct {
 
 
 export type List struct {
-	len_ int;
+	len int;
 	first, last *Elem;
 };
 
@@ -70,17 +75,12 @@ export type Flags struct {
 	print_interface bool;
 	verbosity uint;
 	sixg bool;
-
-	scan bool;
-	parse bool;
-	ast bool;
-	deps bool;
 	token_chan bool;
 }
 
 
 export type Environment struct {
-	Error *(comp *Compilation);  // TODO complete this
+	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);
@@ -92,6 +92,14 @@ export type Compilation struct {
 	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;
@@ -99,6 +107,7 @@ export type Compilation struct {
 
 
 export type Expr interface {
+	op() int;  // node operation
 	pos() int;  // source position
 	typ() *Type;
 	// ... more to come here
@@ -113,7 +122,7 @@ export type Stat interface {
 // TODO This is hideous! We need to have a decent way to do lists.
 // Ideally open arrays that allow '+'.
 
-type Elem struct {
+export type Elem struct {
 	next *Elem;
 	val int;
 	str string;
@@ -129,7 +138,7 @@ type Elem struct {
 export var Universe_void_t *Type  // initialized by Universe to Universe.void_t
 
 export func NewObject(pos, kind int, ident string) *Object {
-	obj := new(*Object);
+	obj := new(Object);
 	obj.exported = false;
 	obj.pos = pos;
 	obj.kind = kind;
@@ -141,7 +150,7 @@ export func NewObject(pos, kind int, ident string) *Object {
 
 
 export func NewType(form int) *Type {
-	typ := new(*Type);
+	typ := new(Type);
 	typ.ref = -1;  // not yet exported
 	typ.form = form;
 	return typ;
@@ -149,7 +158,7 @@ export func NewType(form int) *Type {
 
 
 export func NewPackage(file_name string, obj *Object, scope *Scope) *Package {
-	pkg := new(*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
@@ -160,12 +169,12 @@ export func NewPackage(file_name string, obj *Object, scope *Scope) *Package {
 
 
 export func NewList() *List {
-	return new(*List);
+	return new(List);
 }
 
 
 export func NewScope(parent *Scope) *Scope {
-	scope := new(*Scope);
+	scope := new(Scope);
 	scope.parent = parent;
 	scope.entries = NewList();
 	return scope;
@@ -176,7 +185,7 @@ export func NewScope(parent *Scope) *Scope {
 // Object methods
 
 func (obj *Object) Copy() *Object {
-	copy := new(*Object);
+	copy := new(Object);
 	copy.exported = obj.exported;
 	copy.pos = obj.pos;
 	copy.kind = obj.kind;
@@ -191,7 +200,7 @@ func (obj *Object) Copy() *Object {
 // List methods
 
 func (L *List) at(i int) *Elem {
-	if i < 0 || L.len_ <= i {
+	if i < 0 || L.len <= i {
 		panic("index out of bounds");
 	}
 
@@ -205,13 +214,13 @@ func (L *List) at(i int) *Elem {
 
 
 func (L *List) Clear() {
-	L.len_, L.first, L.last = 0, nil, nil;
+	L.len, L.first, L.last = 0, nil, nil;
 }
 
 
 func (L *List) Add() *Elem {
-	L.len_++;
+	L.len++;
-	e := new(*Elem);
+	e := new(Elem);
 	if L.first == nil {
 		L.first = e;
 	} else {
@@ -242,6 +251,11 @@ func (L *List) TypAt(i int) *Type {
 }
 
 
+func (L *List) ExprAt(i int) Expr {
+	return L.at(i).expr;
+}
+
+
 func (L *List) AddInt(val int) {
 	L.Add().val = val;
 }
@@ -280,18 +294,23 @@ func (scope *Scope) Lookup(ident string) *Object {
 }
 
 
+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.entries.AddObj(obj);
+	scope.Add(obj);
 }
 
 
 func (scope *Scope) InsertImport(obj *Object) *Object {
 	 p := scope.Lookup(obj.ident);
 	 if p == nil {
-		scope.Insert(obj);
+		scope.Add(obj);
 		p = obj;
 	 }
 	 return p;

usr/gri/gosrc/go.go

@@ -20,10 +20,6 @@ func PrintHelp() {
 		"  -p             print package interface\n" +
 		"  -v [0 .. 3]    verbosity level\n" +
 		"  -6g            6g compatibility mode\n" +
-		"  -scan          scan only, print tokens\n" +
-		"  -parse         parse only, print productions\n" +
-		"  -ast           analyse only, print ast\n" +
-		"  -deps          print package dependencies\n" +
 		"  -token_chan    use token channel to scan and parse in parallel\n"
 	);
 }
@@ -49,7 +45,7 @@ func main() {
 	}
 
 	// collect flags and files
-	flags := new(*Globals.Flags);
+	flags := new(Globals.Flags);
 	files := Globals.NewList();
 	for arg != "" {
 	    switch arg {
@@ -69,13 +65,6 @@ func main() {
 				continue;
 			}
 		case "-6g": flags.sixg = true;
-		case "-scan": flags.scan = true;
-			print("note: -scan flag ignored at the moment\n");
-		case "-parse": flags.parse = true;
-			print("note: -parse flag ignored at the moment\n");
-		case "-ast": flags.ast = true;
-		case "-deps": flags.deps = true;
-			print("note: -deps flag ignored at the moment\n");
 		case "-token_chan": flags.token_chan = true;
 		default: files.AddStr(arg);
 		}
@@ -83,7 +72,8 @@ func main() {
 	}
 
 	// setup environment
-	env := new(*Globals.Environment);
+	env := new(Globals.Environment);
+	env.Error = &Compilation.Error;
 	env.Import = &Compilation.Import;
 	env.Export = &Compilation.Export;
 	env.Compile = &Compilation.Compile;
@@ -91,7 +81,7 @@ func main() {
 	// compile files
 	for p := files.first; p != nil; p = p.next {
 		// setup compilation
-		comp := new(*Globals.Compilation);
+		comp := new(Globals.Compilation);
 		comp.flags = flags;
 		comp.env = env;
 

usr/gri/gosrc/import.go

@@ -200,24 +200,32 @@ func (I *Importer) ReadType() *Globals.Type {
 	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);
-		break;
+		
+	case Type.TUPLE:
+		typ.elt = I.ReadType();
 		
 	case Type.ALIAS, Type.MAP:
-		typ.aux = I.ReadType();
+		typ.key = I.ReadType();
 		typ.elt = I.ReadType();
 
 	case Type.ARRAY:
-		typ.len_ = I.ReadInt();
+		typ.len = I.ReadInt();
 		typ.elt = I.ReadType();
 
 	case Type.CHANNEL:
-		typ.flags = I.ReadInt();
+		typ.aux = I.ReadInt();
 		typ.elt = I.ReadType();
 
-	case Type.FUNCTION:
+	case Type.FUNCTION, Type.METHOD:
-		typ.flags = I.ReadInt();
+		typ.len = I.ReadInt();
+		typ.elt = I.ReadType();
 		typ.scope = Globals.NewScope(nil);
 		I.ReadScope(typ.scope, false);
 
@@ -225,7 +233,7 @@ func (I *Importer) ReadType() *Globals.Type {
 		typ.scope = Globals.NewScope(nil);
 		I.ReadScope(typ.scope, false);
 
-	case Type.POINTER, Type.REFERENCE:
+	case Type.POINTER:
 		typ.elt = I.ReadType();
 
 	default:

usr/gri/gosrc/object.go

@@ -9,7 +9,7 @@ import Globals "globals"
 
 export const /* kind */ (
 	BAD = iota;  // error handling
-	CONST; TYPE; VAR; FIELD; FUNC; PACKAGE; LABEL;
+	CONST; TYPE; VAR; FIELD; FUNC; BUILTIN; PACKAGE; LABEL;
 	END;  // end of scope (import/export only)
 )
 
@@ -27,6 +27,7 @@ export func KindStr(kind int) string {
 	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";

usr/gri/gosrc/printer.go

@@ -40,7 +40,7 @@ func IsAnonymous(name string) bool {
 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.TypAt(a));  // result type only
+		P.PrintType(scope.entries.ObjAt(a).typ);  // result type only
 	} else {
 		print("(");
 		for i := a; i < b; i++ {
@@ -57,16 +57,16 @@ func (P *Printer) PrintSigRange(typ *Globals.Type, a, b int) {
 
 
 func (P *Printer) PrintSignature(typ *Globals.Type, fun *Globals.Object) {
-	if typ.form != Type.FUNCTION {
-		panic("typ.form != Type.FUNCTION");
-	}
-	
 	p0 := 0;
-	if typ.flags & Type.RECV != 0 {
+	if typ.form == Type.METHOD {
 		p0 = 1;
+	} else {
+		if typ.form != Type.FUNCTION {
+			panic("not a function or method");
+		}
 	}
-	r0 := p0 + typ.len_;
+	r0 := p0 + typ.len;
-	l0 := typ.scope.entries.len_;
+	l0 := typ.scope.entries.len;
 	
 	if P.level == 0 {
 		print("func ");
@@ -105,7 +105,7 @@ 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_;
+		n = scope.entries.len;
 	} else {
 		n = 0;
 		for p := scope.entries.first; p != nil; p = p.next {
@@ -134,8 +134,8 @@ func (P *Printer) PrintScope(scope *Globals.Scope, delta int) {
 func (P *Printer) PrintObjectStruct(obj *Globals.Object) {
 	switch obj.kind {
 	case Object.BAD:
-		print("bad ");
 		P.PrintObject(obj);
+		print(" /* bad */");
 
 	case Object.CONST:
 		print("const ");
@@ -149,10 +149,11 @@ func (P *Printer) PrintObjectStruct(obj *Globals.Object) {
 		print(" ");
 		P.PrintTypeStruct(obj.typ);
 
-	case Object.VAR, Object.FIELD:
+	case Object.VAR:
-		if P.level == 0 {
+		print("var ");
-			print("var ");
+		fallthrough;
-		}
+
+	case Object.FIELD:
 		P.PrintObject(obj);
 		print(" ");
 		P.PrintType(obj.typ);
@@ -160,6 +161,10 @@ func (P *Printer) PrintObjectStruct(obj *Globals.Object) {
 	case Object.FUNC:
 		P.PrintSignature(obj.typ, obj);
 
+	case Object.BUILTIN:
+		P.PrintObject(obj);
+		print(" /* builtin */");
+		
 	case Object.PACKAGE:
 		print("package ");
 		P.PrintObject(obj);
@@ -197,11 +202,14 @@ func (P *Printer) PrintTypeStruct(typ *Globals.Type) {
 	case Type.VOID:
 		print("void");
 		
+	case Type.BAD:
+		print("<bad type>");
+
 	case Type.FORWARD:
 		print("<forward type>");
 
-	case Type.BAD:
+	case Type.TUPLE:
-		print("<bad type>");
+		print("<tuple type>");
 
 	case Type.NIL, Type.BOOL, Type.UINT, Type.INT, Type.FLOAT, Type.STRING, Type.ANY:
 		if typ.obj == nil {
@@ -211,9 +219,9 @@ func (P *Printer) PrintTypeStruct(typ *Globals.Type) {
 
 	case Type.ALIAS:
 		P.PrintType(typ.elt);
-		if typ.aux != typ.elt {
+		if typ.key != typ.elt {
 			print(" /* ");
-			P.PrintType(typ.aux);
+			P.PrintType(typ.key);
 			print(" */");
 		}
 		
@@ -233,12 +241,12 @@ func (P *Printer) PrintTypeStruct(typ *Globals.Type) {
 
 	case Type.MAP:
 		print("map [");
-		P.PrintType(typ.aux);
+		P.PrintType(typ.key);
 		print("] ");
 		P.PrintType(typ.elt);
 
 	case Type.CHANNEL:
-		switch typ.flags {
+		switch typ.aux {
 		case Type.SEND: print("chan <- ");
 		case Type.RECV: print("<- chan ");
 		case Type.SEND + Type.RECV: print("chan ");
@@ -253,10 +261,6 @@ func (P *Printer) PrintTypeStruct(typ *Globals.Type) {
 		print("*");
 		P.PrintType(typ.elt);
 
-	case Type.REFERENCE:
-		print("&");
-		P.PrintType(typ.elt);
-
 	default:
 		panic("UNREACHABLE");
 		

usr/gri/gosrc/scanner.go

@@ -86,7 +86,6 @@ export const (
 	ELSE;
 	EXPORT;
 	FALLTHROUGH;
-	FALSE;
 	FOR;
 	FUNC;
 	GO;
@@ -94,17 +93,13 @@ export const (
 	IF;
 	IMPORT;
 	INTERFACE;
-	IOTA;
 	MAP;
-	NEW;
-	NIL;
 	PACKAGE;
 	RANGE;
 	RETURN;
 	SELECT;
 	STRUCT;
 	SWITCH;
-	TRUE;
 	TYPE;
 	VAR;
 	KEYWORDS_END;
@@ -191,7 +186,6 @@ export func TokenName(tok int) string {
 	case ELSE: return "else";
 	case EXPORT: return "export";
 	case FALLTHROUGH: return "fallthrough";
-	case FALSE: return "false";
 	case FOR: return "for";
 	case FUNC: return "func";
 	case GO: return "go";
@@ -199,17 +193,13 @@ export func TokenName(tok int) string {
 	case IF: return "if";
 	case IMPORT: return "import";
 	case INTERFACE: return "interface";
-	case IOTA: return "iota";
 	case MAP: return "map";
-	case NEW: return "new";
-	case NIL: return "nil";
 	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 TRUE: return "true";
 	case TYPE: return "type";
 	case VAR: return "var";
 	}
@@ -219,7 +209,7 @@ export func TokenName(tok int) string {
 
 
 func init() {
-	Keywords = new(map [string] int);
+	Keywords = make(map [string] int);
 
 	for i := KEYWORDS_BEG; i <= KEYWORDS_END; i++ {
 	  Keywords[TokenName(i)] = i;
@@ -578,14 +568,14 @@ func (S *Scanner) ScanDigits(n int, base int) {
 }
 
 
-func (S *Scanner) ScanEscape() string {
+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', '\\', '\'', '"':
+	case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\':
 		return string(ch);
 
 	case '0', '1', '2', '3', '4', '5', '6', '7':
@@ -605,6 +595,10 @@ func (S *Scanner) ScanEscape() string {
 		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");
 	}
 	
@@ -619,7 +613,7 @@ func (S *Scanner) ScanChar() string {
 	ch := S.ch;
 	S.Next();
 	if ch == '\\' {
-		S.ScanEscape();
+		S.ScanEscape('\'');
 	}
 
 	S.Expect('\'');
@@ -639,7 +633,7 @@ func (S *Scanner) ScanString() string {
 			break;
 		}
 		if ch == '\\' {
-			S.ScanEscape();
+			S.ScanEscape('"');
 		}
 	}
 
@@ -781,7 +775,7 @@ export type Token struct {
 
 func (S *Scanner) Server(c chan *Token) {
 	for {
-		t := new(*Token);
+		t := new(Token);
 		t.tok, t.pos, t.val = S.Scan();
 		c <- t;
 		if t.tok == EOF {

usr/gri/gosrc/test_scanner.go

@@ -8,7 +8,7 @@ import Scanner "scanner"
 
 
 func Scan1(filename, src string) {
-	S := new(*Scanner.Scanner);
+	S := new(Scanner.Scanner);
 	S.Open(filename, src);
 	for {
 		tok, pos, val := S.Scan();
@@ -25,9 +25,9 @@ func Scan1(filename, src string) {
 
 
 func Scan2(filename, src string) {
-	S := new(*Scanner.Scanner);
+	S := new(Scanner.Scanner);
 	S.Open(filename, src);
-	c := new(chan *Scanner.Token, 32);
+	c := make(chan *Scanner.Token, 32);
 	go S.Server(c);
 	for {
 		var t *Scanner.Token;

usr/gri/gosrc/type.go

@@ -10,8 +10,12 @@ import Object "object"
 
 export const /* form */ (
 	// internal types
-	// VOID types are used when we don't have a type.
+	// We should never see one of these.
-	VOID = iota;
+	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
@@ -23,6 +27,10 @@ export const /* form */ (
 	// their internals are accessible.
 	FORWARD;
 
+	// TUPLE types represent multi-valued result types of functions and
+	// methods.
+	TUPLE;
+	
 	// The type of nil.
 	NIL;
 
@@ -33,13 +41,13 @@ export const /* form */ (
 	ANY;
 	
 	// composite types
-	ALIAS; ARRAY; STRUCT; INTERFACE; MAP; CHANNEL; FUNCTION; POINTER; REFERENCE;
+	ALIAS; ARRAY; STRUCT; INTERFACE; MAP; CHANNEL; FUNCTION; METHOD; POINTER;
 )
 
 
-export const /* flag */ (
+export const /* Type.aux */ (
-	SEND = 1 << iota;  // chan>
+	SEND = 1;  // chan>
-	RECV;  // chan< or method
+	RECV = 2;  // chan<
 )
 
 
@@ -53,6 +61,7 @@ export func FormStr(form int) string {
 	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";
@@ -67,8 +76,8 @@ export func FormStr(form int) string {
 	case MAP: return "MAP";
 	case CHANNEL: return "CHANNEL";
 	case FUNCTION: return "FUNCTION";
+	case METHOD: return "METHOD";
 	case POINTER: return "POINTER";
-	case REFERENCE: return "REFERENCE";
 	}
 	return "<unknown Type form>";
 }
@@ -102,25 +111,24 @@ func Equal0(x, y *Globals.Type) bool {
 
 	case ARRAY:
 		return
-			x.len_ == y.len_ &&
+			x.len == y.len &&
 			Equal(x.elt, y.elt);
 
 	case MAP:
 		return
-			Equal(x.aux, y.aux) &&
+			Equal(x.key, y.key) &&
 			Equal(x.elt, y.elt);
 
 	case CHANNEL:
 		return
-			x.flags == y.flags &&
+			x.aux == y.aux &&
 			Equal(x.elt, y.elt);
 
-	case FUNCTION:
+	case FUNCTION, METHOD:
 		{	xp := x.scope.entries;
 			yp := x.scope.entries;
-			if	x.flags != y.flags &&  // function or method
+			if	x.len != y.len &&  // number of parameters
-				x.len_ != y.len_ &&  // number of parameters
+				xp.len != yp.len  // recv + parameters + results
-				xp.len_ != yp.len_  // recv + parameters + results
 			{
 				return false;
 			}
@@ -163,8 +171,12 @@ func Equal0(x, y *Globals.Type) bool {
 		panic("UNIMPLEMENTED");
 		return false;
 
-	case POINTER, REFERENCE:
+	case POINTER:
 		return Equal(x.elt, y.elt);
+		
+	case TUPLE:
+		panic("UNIMPLEMENTED");
+		return false;
 	}
 
 	panic("UNREACHABLE");

usr/gri/gosrc/universe.go

@@ -48,7 +48,9 @@ export var (
 	ptrint_t *Globals.Type;
 	
 	true_,
-	false_ *Globals.Object;
+	false_,
+	iota_,
+	nil_ *Globals.Object;
 )
 
 
@@ -72,17 +74,17 @@ func DeclType(form int, ident string, size int) *Globals.Type {
 
 func DeclAlias(ident string, typ *Globals.Type) *Globals.Type {
 	alias := Globals.NewType(Type.ALIAS);
-	alias.aux = typ;
+	alias.key = typ;
 	alias.elt = typ;
 	return DeclObj(Object.TYPE, ident, alias).typ;
 }
 
 
 func Register(typ *Globals.Type) *Globals.Type {
-	if types.len_ < 0 {
+	if types.len < 0 {
-		panic("types.len_ < 0");
+		panic("types.len < 0");
 	}
-	typ.ref = types.len_;
+	typ.ref = types.len;
 	types.AddTyp(typ);
 	return typ;
 }
@@ -96,7 +98,7 @@ func init() {
 	void_t = Globals.NewType(Type.VOID);
 	Globals.Universe_void_t = void_t;
 	bad_t = Globals.NewType(Type.BAD);
-	nil_t = DeclType(Type.NIL, "nil", 8);
+	nil_t = Globals.NewType(Type.NIL);
 	
 	// Basic types
 	bool_t = Register(DeclType(Type.BOOL, "bool", 1));
@@ -130,9 +132,14 @@ func init() {
 	// 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.FUNC, "len", Globals.NewType(Type.FUNCTION));  // incomplete
+	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();
 }

usr/gri/gosrc/verifier.go

@@ -46,11 +46,15 @@ func (V *Verifier) VerifyType(typ *Globals.Type) {
 
 	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;
@@ -82,8 +86,6 @@ func (V *Verifier) VerifyType(typ *Globals.Type) {
 		break;
 	case Type.POINTER:
 		break;
-	case Type.REFERENCE:
-		break;
 	default:
 		Error("illegal type form " + Type.FormStr(typ.form));
 	}
@@ -139,12 +141,12 @@ func (V *Verifier) VerifyPackage(pkg *Globals.Package, pno int) {
 func (V *Verifier) Verify(comp *Globals.Compilation) {
 	// initialize Verifier
 	V.comp = comp;
-	V.objs = new(map[*Globals.Object] bool);
+	V.objs = make(map[*Globals.Object] bool);
-	V.typs = new(map[*Globals.Type] bool);
+	V.typs = make(map[*Globals.Type] bool);
-	V.pkgs = new(map[*Globals.Package] bool);
+	V.pkgs = make(map[*Globals.Package] bool);
 
 	// verify all packages
-	filenames := new(map[string] bool);
+	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
@@ -158,6 +160,6 @@ func (V *Verifier) Verify(comp *Globals.Compilation) {
 
 
 export func Verify(comp *Globals.Compilation) {
-	V := new(*Verifier);
+	V := new(Verifier);
 	V.Verify(comp);
 }