// 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 Scanner "scanner"
import AST "ast"


export type Parser struct {
	verbose bool;
	indent uint;
	scanner *Scanner.Scanner;
	tokchan *<-chan *Scanner.Token;
	
	// Scanner.Token
	pos int;  // token source position
	tok int;  // one token look-ahead
	val string;  // token value (for IDENT, NUMBER, STRING only)
	
	// Non-syntactic parser control
	opt_semi bool;  // true if semicolon is optional

	// Nesting levels
	expr_lev int;  // 0 = control clause level, 1 = expr inside ()'s
	scope_lev int;  // 0 = global scope, 1 = function scope of global functions, etc.
};


// ----------------------------------------------------------------------------
// 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.pos, P.tok, P.val = P.scanner.Scan();
	} else {
		t := <-P.tokchan;
		P.tok, P.pos, P.val = t.tok, t.pos, t.val;
	}
	P.opt_semi = false;
	if P.verbose {
		P.PrintIndent();
		print("[", P.pos, "] ", Scanner.TokenName(P.tok), "\n");
	}
}


func (P *Parser) Open(verbose bool, scanner *Scanner.Scanner, tokchan *<-chan *Scanner.Token) {
	P.verbose = verbose;
	P.indent = 0;
	P.scanner = scanner;
	P.tokchan = tokchan;
	P.Next();
	P.expr_lev = 1;
	P.scope_lev = 0;
}


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) OptSemicolon() {
	if P.tok == Scanner.SEMICOLON {
		P.Next();
	}
}


// ----------------------------------------------------------------------------
// Common productions

func (P *Parser) TryType() (typ AST.Type, ok bool);
func (P *Parser) ParseExpression() AST.Expr;
func (P *Parser) ParseStatement() AST.Stat;
func (P *Parser) ParseDeclaration() AST.Node;


func (P *Parser) ParseIdent() *AST.Ident {
	P.Trace("Ident");

	ident := new(AST.Ident);
	ident.pos, ident.val = P.pos, "";
	if P.tok == Scanner.IDENT {
		ident.val = P.val;
		if P.verbose {
			P.PrintIndent();
			print("Ident = \"", ident.val, "\"\n");
		}
		P.Next();
	} else {
		P.Expect(Scanner.IDENT);  // use Expect() error handling
	}
	
	P.Ecart();
	return ident;
}


func (P *Parser) ParseIdentList() *AST.List {
	P.Trace("IdentList");

	list := AST.NewList();
	list.Add(P.ParseIdent());
	for P.tok == Scanner.COMMA {
		P.Next();
		list.Add(P.ParseIdent());
	}

	P.Ecart();
	return list;
}


func (P *Parser) ParseQualifiedIdent() AST.Expr {
	P.Trace("QualifiedIdent");

	ident := P.ParseIdent();
	var qident AST.Expr = ident;

	for P.tok == Scanner.PERIOD {
		pos := P.pos;
		P.Next();
		y := P.ParseIdent();

		z := new(AST.Selector);
		z.pos, z.x, z.field = pos, qident, y.val;
		qident = z;
	}
	
	P.Ecart();
	return qident;
}


// ----------------------------------------------------------------------------
// Types

func (P *Parser) ParseType() AST.Type {
	P.Trace("Type");
	
	typ, ok := P.TryType();
	if !ok {
		P.Error(P.pos, "type expected");
	}
	
	P.Ecart();
	return typ;
}


func (P *Parser) ParseVarType() AST.Type {
	P.Trace("VarType");
	
	typ := P.ParseType();
	
	P.Ecart();
	return typ;
}


func (P *Parser) ParseTypeName() AST.Type {
	P.Trace("TypeName");
	
	typ := P.ParseQualifiedIdent();

	P.Ecart();
	return typ;
}


func (P *Parser) ParseArrayType() *AST.ArrayType {
	P.Trace("ArrayType");
	
	typ := new(AST.ArrayType);
	typ.pos = P.pos;
	typ.len_ = AST.NIL;
	
	P.Expect(Scanner.LBRACK);
	if P.tok != Scanner.RBRACK {
		// TODO set typ.len
		typ.len_ = P.ParseExpression();
	}
	P.Expect(Scanner.RBRACK);
	typ.elt = P.ParseType();

	P.Ecart();
	return typ;
}


func (P *Parser) ParseChannelType() *AST.ChannelType {
	P.Trace("ChannelType");
	
	typ := new(AST.ChannelType);
	typ.pos = P.pos;
	typ.mode = AST.FULL;
	
	if P.tok == Scanner.CHAN {
		P.Next();
		if P.tok == Scanner.ARROW {
			P.Next();
			typ.mode = AST.SEND;
		}
	} else {
		P.Expect(Scanner.ARROW);
		P.Expect(Scanner.CHAN);
		typ.mode = AST.RECV;
	}
	typ.elt = P.ParseVarType();

	P.Ecart();
	return typ;
}


func (P *Parser) ParseVarDeclList() *AST.VarDeclList {
	P.Trace("VarDeclList");

	vars := new(AST.VarDeclList);
	vars.idents = AST.NewList();
	vars.typ = AST.NIL;
	
	vars.idents.Add(P.ParseType());
	for P.tok == Scanner.COMMA {
		P.Next();
		vars.idents.Add(P.ParseType());
	}
	
	var ok bool;
	vars.typ, ok = P.TryType();

	if !ok {
		// we must have a list of types
	}
	
	P.Ecart();
	return vars;
}


// Returns a list of *AST.VarDeclList or Type
func (P *Parser) ParseParameterList() *AST.List {
	P.Trace("ParameterList");
	
	list := AST.NewList();
	list.Add(P.ParseVarDeclList());
	for P.tok == Scanner.COMMA {
		P.Next();
		list.Add(P.ParseVarDeclList());
	}
	
	P.Ecart();
	return list;
}


// Returns a list of AST.VarDeclList
func (P *Parser) ParseParameters() *AST.List {
	P.Trace("Parameters");
	
	var list *AST.List;
	P.Expect(Scanner.LPAREN);
	if P.tok != Scanner.RPAREN {
		list = P.ParseParameterList();
	}
	P.Expect(Scanner.RPAREN);
	
	P.Ecart();
	return list;
}


func (P *Parser) ParseResultList() {
	P.Trace("ResultList");

	P.ParseType();
	for P.tok == Scanner.COMMA {
		P.Next();
		P.ParseType();
	}
	if P.tok != Scanner.RPAREN {
		P.ParseType();
	}

	P.Ecart();
}


func (P *Parser) ParseResult() *AST.List {
	P.Trace("Result");
	
	var result *AST.List;
	if P.tok == Scanner.LPAREN {
		result = P.ParseParameters();
	} else {
		typ, ok := P.TryType();
		if ok {
			vars := new(AST.VarDeclList);
			vars.typ = typ;
			list := AST.NewList();
			list.Add(vars);
			result = list;
		}
	}

	P.Ecart();
	return result;
}


// Function types
//
// (params)
// (params) type
// (params) (results)

func (P *Parser) ParseFunctionType() *AST.FunctionType {
	P.Trace("FunctionType");
	
	typ := new(AST.FunctionType);
	typ.pos = P.pos;
	typ.params = P.ParseParameters();
	typ.result = P.ParseResult();
	
	P.Ecart();
	return typ;
}


func (P *Parser) ParseMethodDecl() *AST.MethodDecl {
	P.Trace("MethodDecl");
	
	decl := new(AST.MethodDecl);
	decl.ident = P.ParseIdent();
	decl.typ = P.ParseFunctionType();
	
	P.Ecart();
	return decl;
}


func (P *Parser) ParseInterfaceType() *AST.InterfaceType {
	P.Trace("InterfaceType");
	
	typ := new(AST.InterfaceType);
	typ.pos = P.pos;
	typ.methods = AST.NewList();
	
	P.Expect(Scanner.INTERFACE);
	
	if P.tok == Scanner.LBRACE {
		P.Next();
		for P.tok == Scanner.IDENT {
			typ.methods.Add(P.ParseMethodDecl());
			if P.tok != Scanner.RBRACE {
				P.Expect(Scanner.SEMICOLON);
			}
		}
		P.Expect(Scanner.RBRACE);
	}

	P.Ecart();
	return typ;
}


func (P *Parser) ParseMapType() *AST.MapType {
	P.Trace("MapType");
	
	typ := new(AST.MapType);
	typ.pos = P.pos;
	
	P.Expect(Scanner.MAP);
	P.Expect(Scanner.LBRACK);
	typ.key = P.ParseVarType();
	P.Expect(Scanner.RBRACK);
	typ.val = P.ParseVarType();
	
	P.Ecart();
	return typ;
}


func (P *Parser) ParseStructType() *AST.StructType {
	P.Trace("StructType");

	typ := new(AST.StructType);
	typ.pos = P.pos;
	typ.fields = AST.NewList();
	
	P.Expect(Scanner.STRUCT);
	
	if P.tok == Scanner.LBRACE {
		P.Next();
		for P.tok == Scanner.IDENT {
			typ.fields.Add(P.ParseVarDeclList());
			if P.tok != Scanner.RBRACE {
				P.Expect(Scanner.SEMICOLON);
			}
		}
		P.OptSemicolon();
		P.Expect(Scanner.RBRACE);
	}

	P.Ecart();
	return typ;
}


func (P *Parser) ParsePointerType() *AST.PointerType {
	P.Trace("PointerType");
	
	typ := new(AST.PointerType);
	typ.pos = P.pos;
	
	P.Expect(Scanner.MUL);
	typ.base = P.ParseType();
	
	P.Ecart();
	return typ;
}


// Returns false if no type was found.
func (P *Parser) TryType() (typ_ AST.Type, ok_ bool) {
	P.Trace("Type (try)");
	
	var typ AST.Type = AST.NIL;
	found := true;
	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();
	default: found = false;
	}

	P.Ecart();
	return typ, found;
}


// ----------------------------------------------------------------------------
// Blocks

func (P *Parser) ParseStatementList() *AST.List {
	P.Trace("StatementList");
	
	stats := AST.NewList();
	for P.tok != Scanner.CASE && P.tok != Scanner.DEFAULT && P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
		stats.Add(P.ParseStatement());
		if P.tok == Scanner.SEMICOLON {
			P.Next();
		} else if P.opt_semi {
			P.opt_semi = false;  // "consume" optional semicolon
		} else {
			break;
		}
	}
	
	P.Ecart();
	return stats;
}


func (P *Parser) ParseBlock() *AST.Block {
	P.Trace("Block");
	
	block := new(AST.Block);
	block.pos = P.pos;
	
	P.Expect(Scanner.LBRACE);
	if P.tok != Scanner.RBRACE {
		block.stats = P.ParseStatementList();
	}
	P.OptSemicolon();
	P.Expect(Scanner.RBRACE);
	P.opt_semi = true;
	
	P.Ecart();
	return block;
}


// ----------------------------------------------------------------------------
// Expressions

func (P *Parser) ParseExpressionList(list *AST.List) {
	P.Trace("ExpressionList");

	list.Add(P.ParseExpression());
	for P.tok == Scanner.COMMA {
		P.Next();
		list.Add(P.ParseExpression());
	}
	
	P.Ecart();
}


func (P *Parser) ParseNewExpressionList() *AST.List {
	list := AST.NewList();
	P.ParseExpressionList(list);
	return list;
}


func (P *Parser) ParseFunctionLit() *AST.FunctionLit {
	P.Trace("FunctionLit");
	
	fun := new(AST.FunctionLit);
	fun.pos = P.pos;
	
	P.Expect(Scanner.FUNC);
	fun.typ = P.ParseFunctionType();
	P.scope_lev++;
	fun.body = P.ParseBlock();
	P.scope_lev--;
	
	P.Ecart();
	return fun;
}


func (P *Parser) ParseExpressionPair() AST.Expr {
	P.Trace("ExpressionPair");

	p := new(AST.Pair);
	p.x = P.ParseExpression();
	p.pos = P.pos;
	P.Expect(Scanner.COLON);
	p.y = P.ParseExpression();
	
	P.Ecart();
	return p;
}


func (P *Parser) ParseExpressionPairList(list *AST.List) {
	P.Trace("ExpressionPairList");

	list.Add(P.ParseExpressionPair());
	for P.tok == Scanner.COMMA {
		P.Next();
		list.Add(P.ParseExpressionPair());
	}
	
	P.Ecart();
}


func (P *Parser) ParseOperand() AST.Expr {
	P.Trace("Operand");

	var op AST.Expr;

	switch P.tok {
	case Scanner.IDENT:
		op = P.ParseIdent();
		
	case Scanner.LPAREN:
		P.Next();
		P.expr_lev++;
		op = P.ParseExpression();
		P.expr_lev--;
		P.Expect(Scanner.RPAREN);

	case Scanner.INT, Scanner.FLOAT:
		lit := new(AST.Literal);
		lit.pos, lit.tok, lit.val = P.pos, P.tok, P.val;
		op = lit;
		P.Next();

	case Scanner.STRING:
		lit := new(AST.Literal);
		lit.pos, lit.tok = P.pos, P.tok;
		for P.tok == Scanner.STRING {
			lit.val += P.val;
			P.Next();
		}
		op = lit;

	case Scanner.FUNC:
		op = P.ParseFunctionLit();
		
	default:
		typ, ok := P.TryType();
		if ok {
			op = typ;
			break;
		}

		P.Error(P.pos, "operand expected");
		P.Next();  // make progress
	}

	P.Ecart();
	return op;
}


func (P *Parser) ParseSelectorOrTypeGuard(x AST.Expr) AST.Expr {
	P.Trace("SelectorOrTypeGuard");

	pos := P.pos;
	P.Expect(Scanner.PERIOD);
	
	if P.tok == Scanner.IDENT {
		ident := P.ParseIdent();
		
		z := new(AST.Selector);
		z.pos, z.x, z.field = pos, x, ident.val;
		x = z;
		
	} else {
		P.Expect(Scanner.LPAREN);
		P.ParseType();
		P.Expect(Scanner.RPAREN);
	}
	
	P.Ecart();
	return x;
}


func (P *Parser) ParseIndexOrSlice(x AST.Expr) AST.Expr {
	P.Trace("IndexOrSlice");
	
	pos := P.pos;
	P.Expect(Scanner.LBRACK);
	i := P.ParseExpression();
	if P.tok == Scanner.COLON {
		P.Next();
		j := P.ParseExpression();
		// TODO: handle this case
	}
	P.Expect(Scanner.RBRACK);

	z := new(AST.Index);
	z.pos, z.x, z.index = pos, x, i;
	
	P.Ecart();
	return z;
}


func (P *Parser) ParseCall(x AST.Expr) *AST.Call {
	P.Trace("Call");

	call := new(AST.Call);
	call.pos = P.pos;
	call.fun = x;
	call.args = nil;
	
	P.Expect(Scanner.LPAREN);
	if P.tok != Scanner.RPAREN {
		call.args = P.ParseNewExpressionList();
	}
	P.Expect(Scanner.RPAREN);
	
	P.Ecart();
	return call;
}


func (P *Parser) ParseCompositeLit(typ AST.Type) AST.Expr {
	P.Trace("CompositeLit");
	
	lit := new(AST.CompositeLit);
	lit.pos = P.pos;
	lit.typ = typ;
	lit.vals = AST.NewList();
	
	P.Expect(Scanner.LBRACE);
	if P.tok != Scanner.RBRACE {
		x := P.ParseExpression();
		if P.tok == Scanner.COMMA {
			P.Next();
			lit.vals.Add(x);
			if P.tok != Scanner.RBRACE {
				P.ParseExpressionList(lit.vals);
			}
		} else if P.tok == Scanner.COLON {
			p := new(AST.Pair);
			p.pos = P.pos;
			p.x = x;
			P.Next();
			p.y = P.ParseExpression();
			lit.vals.Add(p);
			if P.tok == Scanner.COMMA {
				P.Next();
				if P.tok != Scanner.RBRACE {
					P.ParseExpressionPairList(lit.vals);
				}
			}
		} else {
			lit.vals.Add(x);
		}
	}
	P.Expect(Scanner.RBRACE);

	P.Ecart();
	return lit;
}


func (P *Parser) ParsePrimaryExpr() AST.Expr {
	P.Trace("PrimaryExpr");
	
	x := P.ParseOperand();
	for {
		switch P.tok {
		case Scanner.PERIOD: x = P.ParseSelectorOrTypeGuard(x);
		case Scanner.LBRACK: x = P.ParseIndexOrSlice(x);
		case Scanner.LPAREN: x = P.ParseCall(x);
		case Scanner.LBRACE:
			if P.expr_lev > 0 {
				x = P.ParseCompositeLit(x);
			} else {
				goto exit;
			}
		default: goto exit;
		}
	}
exit:

	P.Ecart();
	return x;
}


func (P *Parser) ParseUnaryExpr() AST.Expr {
	P.Trace("UnaryExpr");
	
	var x AST.Expr = AST.NIL;
	switch P.tok {
	case
		Scanner.ADD, Scanner.SUB,
		Scanner.NOT, Scanner.XOR,
		Scanner.MUL, Scanner.ARROW,
		Scanner.AND:
			pos, tok := P.pos, P.tok;
			P.Next();
			y := P.ParseUnaryExpr();

			z := new(AST.Unary);
			z.pos, z.tok, z.x = pos, tok, y;
			x = z;
			
		default:
			x = P.ParsePrimaryExpr();
	}
	
	P.Ecart();
	return x;
}


func (P *Parser) ParseBinaryExpr(prec1 int) AST.Expr {
	P.Trace("BinaryExpr");
	
	x := P.ParseUnaryExpr();
	for prec := Scanner.Precedence(P.tok); prec >= prec1; prec-- {
		for Scanner.Precedence(P.tok) == prec {
			pos, tok := P.pos, P.tok;
			P.Next();
			y := P.ParseBinaryExpr(prec + 1);
			
			z := new(AST.Binary);
			z.pos, z.tok, z.x, z.y = pos, tok, x, y;
			x = z;
		}
	}
	
	P.Ecart();
	return x;
}


func (P *Parser) ParseExpression() AST.Expr {
	P.Trace("Expression");
	indent := P.indent;
	
	x := P.ParseBinaryExpr(1);
	
	if indent != P.indent {
		panic("imbalanced tracing code (Expression)");
	}

	P.Ecart();
	return x;
}


// ----------------------------------------------------------------------------
// Statements

func (P *Parser) ParseSimpleStat() AST.Stat {
	P.Trace("SimpleStat");
	
	var stat AST.Stat = AST.NIL;
	x := P.ParseNewExpressionList();
	
	switch P.tok {
	case Scanner.COLON:
		// label declaration
		l := new(AST.Label);
		l.pos = P.pos;
		if x.len() == 1 {
			l.ident = x.at(0);
		} else {
			P.Error(P.pos, "illegal label declaration");
			l.ident = AST.NIL;
		}
		P.Next();  // consume ":"
		P.opt_semi = true;
		stat = l;
		
	case
		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:
		pos, tok := P.pos, P.tok;
		P.Next();
		y := P.ParseNewExpressionList();
		a := new(AST.Assignment);
		a.pos, a.tok, a.lhs, a.rhs = pos, tok, x, y;
		stat = a;
		
	default:
		if P.tok == Scanner.INC || P.tok == Scanner.DEC {
			s := new(AST.IncDecStat);
			s.pos, s.tok = P.pos, P.tok;
			if x.len() == 1 {
				s.expr = x.at(0);
			} else {
				P.Error(P.pos, "more then one operand");
			}
			P.Next();
			stat = s;
		} else {
			s := new(AST.ExprStat);
			if x != nil && x.len() > 0 {
				s.expr = x.at(0);
			} else {
				// this is a syntax error
				s.expr = AST.NIL;
			}
			stat = s;
		}
	}
	
	P.Ecart();
	return stat;
}


func (P *Parser) ParseGoStat() *AST.GoStat {
	P.Trace("GoStat");
	
	stat := new(AST.GoStat);
	stat.pos = P.pos;
	
	P.Expect(Scanner.GO);
	stat.expr = P.ParseExpression();
	
	P.Ecart();
	return stat;
}


func (P *Parser) ParseReturnStat() *AST.ReturnStat {
	P.Trace("ReturnStat");
	
	stat := new(AST.ReturnStat);
	stat.pos = P.pos;
	
	P.Expect(Scanner.RETURN);
	if P.tok != Scanner.SEMICOLON && P.tok != Scanner.RBRACE {
		stat.res = P.ParseNewExpressionList();
	}
	
	P.Ecart();
	return stat;
}


func (P *Parser) ParseControlFlowStat(tok int) *AST.ControlFlowStat {
	P.Trace("ControlFlowStat");
	
	stat := new(AST.ControlFlowStat);
	stat.pos, stat.tok = P.pos, P.tok;
	
	P.Expect(tok);
	if P.tok == Scanner.IDENT {
		stat.label = P.ParseIdent();
	}
	
	P.Ecart();
	return stat;
}


func (P *Parser) ParseControlClause(keyword int) *AST.ControlClause {
	P.Trace("StatHeader");
	
	ctrl := new(AST.ControlClause);
	ctrl.init, ctrl.expr, ctrl.post = AST.NIL, AST.NIL, AST.NIL;

	P.Expect(keyword);
	if P.tok != Scanner.LBRACE {
		prev_lev := P.expr_lev;
		P.expr_lev = 0;
		if P.tok != Scanner.SEMICOLON {
			ctrl.init = P.ParseSimpleStat();
			ctrl.has_init = true;
		}
		if P.tok == Scanner.SEMICOLON {
			P.Next();
			if P.tok != Scanner.SEMICOLON && P.tok != Scanner.LBRACE {
				ctrl.expr = P.ParseExpression();
				ctrl.has_expr = true;
			}
			if keyword == Scanner.FOR {
				P.Expect(Scanner.SEMICOLON);
				if P.tok != Scanner.LBRACE {
					ctrl.post = P.ParseSimpleStat();
					ctrl.has_post = true;
				}
			}
		} else {
			ctrl.expr, ctrl.has_expr = ctrl.init, ctrl.has_init;
			ctrl.init, ctrl.has_init = AST.NIL, false;
		}
		P.expr_lev = prev_lev;
	}

	P.Ecart();
	return ctrl;
}


func (P *Parser) ParseIfStat() *AST.IfStat {
	P.Trace("IfStat");

	stat := new(AST.IfStat);
	stat.pos = P.pos;
	stat.ctrl = P.ParseControlClause(Scanner.IF);
	stat.then = P.ParseBlock();
	if P.tok == Scanner.ELSE {
		P.Next();
		if P.tok == Scanner.IF {
			stat.else_ = P.ParseIfStat();
		} else {
			// TODO: Should be P.ParseBlock().
			stat.else_ = P.ParseStatement();
		}
		stat.has_else = true;
	}
	
	P.Ecart();
	return stat;
}


func (P *Parser) ParseForStat() *AST.ForStat {
	P.Trace("ForStat");
	
	stat := new(AST.ForStat);
	stat.pos = P.pos;
	
	stat.ctrl = P.ParseControlClause(Scanner.FOR);
	stat.body = P.ParseBlock();
	
	P.Ecart();
	return stat;
}


func (P *Parser) ParseCase() *AST.CaseClause {
	P.Trace("Case");
	
	clause := new(AST.CaseClause);
	clause.pos = P.pos;
	
	if P.tok == Scanner.CASE {
		P.Next();
		clause.exprs = P.ParseNewExpressionList();
	} else {
		P.Expect(Scanner.DEFAULT);
	}
	P.Expect(Scanner.COLON);
	
	P.Ecart();
	return clause;
}


func (P *Parser) ParseCaseClause() *AST.CaseClause {
	P.Trace("CaseClause");

	clause := P.ParseCase();
	if P.tok != Scanner.CASE && P.tok != Scanner.DEFAULT && P.tok != Scanner.RBRACE {
		clause.stats = P.ParseStatementList();
	}
	
	P.Ecart();
	return clause;
}


func (P *Parser) ParseSwitchStat() *AST.SwitchStat {
	P.Trace("SwitchStat");
	
	stat := new(AST.SwitchStat);
	stat.pos = P.pos;
	stat.ctrl = P.ParseControlClause(Scanner.SWITCH);
	stat.cases = AST.NewList();
	
	P.Expect(Scanner.LBRACE);
	for P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
		stat.cases.Add(P.ParseCaseClause());
	}
	P.Expect(Scanner.RBRACE);
	P.opt_semi = true;

	P.Ecart();
	return stat;
}


func (P *Parser) ParseCommCase() {
  P.Trace("CommCase");
  
  if P.tok == Scanner.CASE {
	P.Next();
	P.ParseExpression();
	if P.tok == Scanner.ASSIGN || P.tok == Scanner.DEFINE {
		P.Next();
		P.Expect(Scanner.ARROW);
		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.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.Expect(Scanner.RBRACE);
	P.opt_semi = true;
	
	P.Ecart();
}


func (P *Parser) ParseFallthroughStat() {
	P.Trace("FallthroughStat");
	
	P.Expect(Scanner.FALLTHROUGH);

	P.Ecart();
}


func (P *Parser) ParseEmptyStat() {
	P.Trace("EmptyStat");
	P.Ecart();
}


func (P *Parser) ParseRangeStat() {
	P.Trace("RangeStat");
	
	P.Expect(Scanner.RANGE);
	P.ParseIdentList();
	P.Expect(Scanner.DEFINE);
	P.ParseExpression();
	P.ParseBlock();
	
	P.Ecart();;
}


func (P *Parser) ParseStatement() AST.Stat {
	P.Trace("Statement");
	indent := P.indent;

	var stat AST.Stat = AST.NIL;
	switch P.tok {
	case Scanner.CONST, Scanner.TYPE, Scanner.VAR:
		stat = P.ParseDeclaration();
	case Scanner.FUNC:
		// for now we do not allow local function declarations
		fallthrough;
	case
		// only the tokens that are legal top-level expression starts
		Scanner.IDENT, Scanner.INT, Scanner.FLOAT, Scanner.STRING, Scanner.LPAREN,  // operand
		Scanner.LBRACK, Scanner.STRUCT,  // composite type
		Scanner.MUL, Scanner.AND, Scanner.ARROW:  // unary
		stat = P.ParseSimpleStat();
	case Scanner.GO:
		stat = P.ParseGoStat();
	case Scanner.RETURN:
		stat = P.ParseReturnStat();
	case Scanner.BREAK, Scanner.CONTINUE, Scanner.GOTO:
		stat = P.ParseControlFlowStat(P.tok);
	case Scanner.LBRACE:
		stat = P.ParseBlock();
	case Scanner.IF:
		stat = P.ParseIfStat();
	case Scanner.FOR:
		stat = P.ParseForStat();
	case Scanner.SWITCH:
		stat = P.ParseSwitchStat();
	case Scanner.RANGE:
		P.ParseRangeStat();
	case Scanner.SELECT:
		P.ParseSelectStat();
	case Scanner.FALLTHROUGH:
		P.ParseFallthroughStat();
	default:
		P.ParseEmptyStat();  // for complete tracing output only
	}

	if indent != P.indent {
		panic("imbalanced tracing code (Statement)");
	}
	P.Ecart();
	return stat;
}


// ----------------------------------------------------------------------------
// Declarations

func (P *Parser) ParseImportSpec() *AST.ImportDecl {
	P.Trace("ImportSpec");
	
	decl := new(AST.ImportDecl);

	if P.tok == Scanner.PERIOD {
		P.Error(P.pos, `"import ." not yet handled properly`);
		P.Next();
	} else if P.tok == Scanner.IDENT {
		decl.ident = P.ParseIdent();
	}
	
	if P.tok == Scanner.STRING {
		// TODO eventually the scanner should strip the quotes
		decl.file = P.val;
		P.Next();
	} else {
		P.Expect(Scanner.STRING);  // use Expect() error handling
	}
	
	P.Ecart();
	return decl;
}


func (P *Parser) ParseConstSpec(exported bool) *AST.ConstDecl {
	P.Trace("ConstSpec");
	
	decl := new(AST.ConstDecl);
	decl.ident = P.ParseIdent();
	var ok bool;
	decl.typ, ok = P.TryType();
	decl.val = AST.NIL;
	
	if P.tok == Scanner.ASSIGN {
		P.Next();
		decl.val = P.ParseExpression();
	}
	
	P.Ecart();
	return decl;
}


func (P *Parser) ParseTypeSpec(exported bool) *AST.TypeDecl {
	P.Trace("TypeSpec");

	decl := new(AST.TypeDecl);
	decl.ident = P.ParseIdent();
	decl.typ = P.ParseType();
	P.opt_semi = true;
	
	P.Ecart();
	return decl;
}


func (P *Parser) ParseVarSpec(exported bool) *AST.VarDecl {
	P.Trace("VarSpec");
	
	decl := new(AST.VarDecl);
	decl.idents = P.ParseIdentList();
	if P.tok == Scanner.ASSIGN {
		P.Next();
		decl.typ = AST.NIL;
		decl.vals = P.ParseNewExpressionList();
	} else {
		decl.typ = P.ParseVarType();
		if P.tok == Scanner.ASSIGN {
			P.Next();
			decl.vals = P.ParseNewExpressionList();
		}
	}
	
	P.Ecart();
	return decl;
}


// TODO Replace this by using function pointers derived from methods.
func (P *Parser) ParseSpec(exported bool, keyword int) AST.Decl {
	switch keyword {
	case Scanner.IMPORT: return P.ParseImportSpec();
	case Scanner.CONST: return P.ParseConstSpec(exported);
	case Scanner.TYPE: return P.ParseTypeSpec(exported);
	case Scanner.VAR: return P.ParseVarSpec(exported);
	}
	panic("UNREACHABLE");
	return AST.NIL;
}


func (P *Parser) ParseDecl(exported bool, keyword int) *AST.Declaration {
	P.Trace("Decl");
	
	decl := new(AST.Declaration);
	decl.decls = AST.NewList();
	decl.pos, decl.tok = P.pos, P.tok;
	
	P.Expect(keyword);
	if P.tok == Scanner.LPAREN {
		P.Next();
		for P.tok != Scanner.RPAREN && P.tok != Scanner.EOF {
			decl.decls.Add(P.ParseSpec(exported, keyword));
			if P.tok == Scanner.SEMICOLON {
				P.Next();
			} else {
				break;
			}
		}
		P.Expect(Scanner.RPAREN);
		P.opt_semi = true;
		
	} else {
		decl.decls.Add(P.ParseSpec(exported, keyword));
	}
	
	P.Ecart();
	return decl;
}


// Function declarations
//
// func        ident (params)
// func        ident (params) type
// func        ident (params) (results)
// func (recv) ident (params)
// func (recv) ident (params) type
// func (recv) ident (params) (results)

func (P *Parser) ParseFunctionDecl(exported bool) *AST.FuncDecl {
	P.Trace("FunctionDecl");
	
	fun := new(AST.FuncDecl);
	fun.pos = P.pos;

	P.Expect(Scanner.FUNC);

	var recv *AST.VarDeclList;
	if P.tok == Scanner.LPAREN {
		pos := P.pos;
		tmp := P.ParseParameters();
		if tmp.len() > 0 {
			recv = tmp.at(0);
		}
		if recv.idents.len() != 1 {
			P.Error(pos, "must have exactly one receiver");
		}
	}
	
	fun.ident = P.ParseIdent();
	fun.typ = P.ParseFunctionType();
	fun.typ.recv = recv;
	
	if P.tok == Scanner.LBRACE {
		P.scope_lev++;
		fun.body = P.ParseBlock();
		P.scope_lev--;
	}
	
	P.Ecart();
	
	return fun;
}


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);

	has_paren := false;
	if P.tok == Scanner.LPAREN {
		P.Next();
		has_paren = true;
	}
	for P.tok == Scanner.IDENT {
		ident := P.ParseIdent();
		if P.tok == Scanner.COMMA {
			P.Next();  // TODO this seems wrong
		}
	}
	if has_paren {
		P.Expect(Scanner.RPAREN)
	}
	
	P.Ecart();
}


func (P *Parser) ParseDeclaration() AST.Node {
	P.Trace("Declaration");
	indent := P.indent;
	
	var node AST.Node;

	exported := false;
	if P.tok == Scanner.EXPORT {
		if P.scope_lev == 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:
		node = P.ParseDecl(exported, P.tok);
	case Scanner.FUNC:
		node = P.ParseFunctionDecl(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();
	return node;
}


// ----------------------------------------------------------------------------
// Program

func (P *Parser) ParseProgram() *AST.Program {
	P.Trace("Program");
	
	pos := P.pos;
	P.Expect(Scanner.PACKAGE);
	ident := P.ParseIdent();
	
	decls := AST.NewList();
	for P.tok == Scanner.IMPORT {
		decls.Add(P.ParseDecl(false, Scanner.IMPORT));
		P.OptSemicolon();
	}
		
	for P.tok != Scanner.EOF {
		decls.Add(P.ParseDeclaration());
		P.OptSemicolon();
	}
	
	P.Ecart();
	
	x := new(AST.Program);
	x.pos, x.ident, x.decls = pos, ident, decls;
	return x;
}