- removed obsolete files from repository

(most of this has been integrated into pretty,
the rest has been archived).

R=r
OCL=23842
CL=23842

1 files changed, 0 insertions, 2041 deletions

diff --git a/usr/gri/gosrc/parser.go b/usr/gri/gosrc/parser.go
deleted file mode 100644
index a6064316c..000000000
--- 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();
-}