Type struct;
Block struct;
- Lit struct;
- Expr struct;
+ Expr interface;
Stat struct;
Decl struct;
)
}
-// ----------------------------------------------------------------------------
-// Literals
-
-type Lit struct {
- Node;
-
- // Identifiers
- Obj *Object;
-
- // Constant literals
-
- // Type literals
- Len *Expr; // array length
- Dir int; // channel direction
- Key *Type; // receiver or map key type
- Elt *Type; // array, map, channel, pointer element, or function result type
- List *array.Array; End int; // struct fields, interface methods, function parameters
-}
-
-
// ----------------------------------------------------------------------------
// Scopes
}
-// ----------------------------------------------------------------------------
-// Blocks
-//
-// Syntactic constructs of the form:
-//
-// "{" StatementList "}"
-// ":" StatementList
-
-type Block struct {
- Node;
- List *array.Array;
- End int; // position of closing "}" if present
-}
-
-
-func NewBlock(pos, tok int) *Block {
- assert(tok == Scanner.LBRACE || tok == Scanner.COLON);
- b := new(Block);
- b.Pos, b.Tok, b.List = pos, tok, array.New(0);
- return b;
-}
-
-
-// ----------------------------------------------------------------------------
-// Expressions
-
-type Expr struct {
- Node;
- X, Y *Expr; // binary (X, Y) and unary (Y) expressions
- Obj *Object; // identifiers, literals
- Typ *Type;
-}
-
-
-// Length of a comma-separated expression list.
-func (x *Expr) Len() int {
- if x == nil {
- return 0;
- }
- n := 1;
- for ; x.Tok == Scanner.COMMA; x = x.Y {
- n++;
- }
- return n;
-}
-
-
-// The i'th expression in a comma-separated expression list.
-func (x *Expr) At(i int) *Expr {
- for j := 0; j < i; j++ {
- assert(x.Tok == Scanner.COMMA);
- x = x.Y;
- }
- if x.Tok == Scanner.COMMA {
- x = x.X;
- }
- return x;
-}
-
-
-func NewExpr(pos, tok int, x, y *Expr) *Expr {
- if x != nil && x.Tok == Scanner.TYPE || y != nil && y.Tok == Scanner.TYPE {
- panic("no type expression allowed");
- }
- e := new(Expr);
- e.Pos, e.Tok, e.X, e.Y = pos, tok, x, y;
- return e;
-}
-
-
-// TODO probably don't need the tok parameter eventually
-func NewLit(tok int, obj *Object) *Expr {
- e := new(Expr);
- e.Pos, e.Tok, e.Obj, e.Typ = obj.Pos, tok, obj, obj.Typ;
- return e;
-}
-
-
-var BadExpr = NewExpr(0, Scanner.ILLEGAL, nil, nil);
-
-
// ----------------------------------------------------------------------------
// Types
// syntactic components
Pos int; // source position (< 0 if unknown position)
- Expr *Expr; // type name, array length
+ Expr Expr; // type name, array length
Mode int; // channel mode
Key *Type; // receiver type or map key
Elt *Type; // type name type, array, map, channel or pointer element type, function result type
}
-func (t *Type) Nfields() int {
- if t.List == nil {
- return 0;
- }
- nx, nt := 0, 0;
- for i, n := 0, t.List.Len(); i < n; i++ {
- if t.List.At(i).(*Expr).Tok == Scanner.TYPE {
- nt++;
- } else {
- nx++;
- }
- }
- if nx == 0 {
- return nt;
- }
- return nx;
-}
-
-
func (typ* Type) String() string {
if typ != nil {
return
}
-// requires complete Type.Pos access
-func NewTypeExpr(typ *Type) *Expr {
- e := new(Expr);
- e.Pos, e.Tok, e.Typ = typ.Pos, Scanner.TYPE, typ;
- return e;
+var BadType = NewType(0, Scanner.ILLEGAL);
+
+
+// ----------------------------------------------------------------------------
+// Blocks
+//
+// Syntactic constructs of the form:
+//
+// "{" StatementList "}"
+// ":" StatementList
+
+type Block struct {
+ Node;
+ List *array.Array;
+ End int; // position of closing "}" if present
}
-// requires complete Type.String access
-func (x *Expr) String() string {
- if x != nil {
- return
- "Expr(" +
- Scanner.TokenString(x.Tok) + ", " +
- x.X.String() + ", " +
- x.Y.String() + ", " +
- x.Obj.String() + ", " +
- x.Typ.String() +
- ")";
+func NewBlock(pos, tok int) *Block {
+ assert(tok == Scanner.LBRACE || tok == Scanner.COLON);
+ b := new(Block);
+ b.Pos, b.Tok, b.List = pos, tok, array.New(0);
+ return b;
+}
+
+
+// ----------------------------------------------------------------------------
+// Expressions
+
+type (
+ Visitor interface;
+
+ Expr interface {
+ Pos() int;
+ Visit(v Visitor);
+ };
+
+ BadExpr struct {
+ Pos_ int;
+ };
+
+ Ident struct {
+ Pos_ int;
+ Obj *Object;
+ };
+
+ BinaryExpr struct {
+ Pos_, Tok int;
+ X, Y Expr;
+ };
+
+ UnaryExpr struct {
+ Pos_, Tok int;
+ X Expr;
+ };
+
+ BasicLit struct {
+ Pos_, Tok int;
+ Val string
+ };
+
+ FunctionLit struct {
+ Pos_ int; // position of "func"
+ Typ *Type;
+ Body *Block;
+ };
+
+ CompositeLit struct {
+ Pos_ int; // position of "{"
+ Typ *Type;
+ Elts Expr;
+ };
+
+ TypeLit struct {
+ Typ *Type;
+ };
+
+ Selector struct {
+ Pos_ int; // position of "."
+ X Expr;
+ Sel *Ident;
+ };
+
+ TypeGuard struct {
+ Pos_ int; // position of "."
+ X Expr;
+ Typ *Type;
+ };
+
+ Index struct {
+ Pos_ int; // position of "["
+ X, I Expr;
+ };
+
+ Call struct {
+ Pos_ int; // position of "("
+ F, Args Expr
+ };
+)
+
+
+type Visitor interface {
+ DoBadExpr(x *BadExpr);
+ DoIdent(x *Ident);
+ DoBinaryExpr(x *BinaryExpr);
+ DoUnaryExpr(x *UnaryExpr);
+ DoBasicLit(x *BasicLit);
+ DoFunctionLit(x *FunctionLit);
+ DoCompositeLit(x *CompositeLit);
+ DoTypeLit(x *TypeLit);
+ DoSelector(x *Selector);
+ DoTypeGuard(x *TypeGuard);
+ DoIndex(x *Index);
+ DoCall(x *Call);
+}
+
+
+func (x *BadExpr) Pos() int { return x.Pos_; }
+func (x *Ident) Pos() int { return x.Pos_; }
+func (x *BinaryExpr) Pos() int { return x.Pos_; }
+func (x *UnaryExpr) Pos() int { return x.Pos_; }
+func (x *BasicLit) Pos() int { return x.Pos_; }
+func (x *FunctionLit) Pos() int { return x.Pos_; }
+func (x *CompositeLit) Pos() int { return x.Pos_; }
+func (x *TypeLit) Pos() int { return x.Typ.Pos; }
+func (x *Selector) Pos() int { return x.Pos_; }
+func (x *TypeGuard) Pos() int { return x.Pos_; }
+func (x *Index) Pos() int { return x.Pos_; }
+func (x *Call) Pos() int { return x.Pos_; }
+
+
+func (x *BadExpr) Visit(v Visitor) { v.DoBadExpr(x); }
+func (x *Ident) Visit(v Visitor) { v.DoIdent(x); }
+func (x *BinaryExpr) Visit(v Visitor) { v.DoBinaryExpr(x); }
+func (x *UnaryExpr) Visit(v Visitor) { v.DoUnaryExpr(x); }
+func (x *BasicLit) Visit(v Visitor) { v.DoBasicLit(x); }
+func (x *FunctionLit) Visit(v Visitor) { v.DoFunctionLit(x); }
+func (x *CompositeLit) Visit(v Visitor) { v.DoCompositeLit(x); }
+func (x *TypeLit) Visit(v Visitor) { v.DoTypeLit(x); }
+func (x *Selector) Visit(v Visitor) { v.DoSelector(x); }
+func (x *TypeGuard) Visit(v Visitor) { v.DoTypeGuard(x); }
+func (x *Index) Visit(v Visitor) { v.DoIndex(x); }
+func (x *Call) Visit(v Visitor) { v.DoCall(x); }
+
+
+
+// Length of a comma-separated expression list.
+func ExprLen(x Expr) int {
+ if x == nil {
+ return 0;
}
- return "nil";
+ n := 1;
+ for {
+ if p, ok := x.(*BinaryExpr); ok && p.Tok == Scanner.COMMA {
+ n++;
+ x = p.Y;
+ } else {
+ break;
+ }
+ }
+ return n;
}
-var BadType = NewType(0, Scanner.ILLEGAL);
+func ExprAt(x Expr, i int) Expr {
+ for j := 0; j < i; j++ {
+ assert(x.(*BinaryExpr).Tok == Scanner.COMMA);
+ x = x.(*BinaryExpr).Y;
+ }
+ if t, is_binary := x.(*BinaryExpr); is_binary && t.Tok == Scanner.COMMA {
+ x = t.X;
+ }
+ return x;
+}
+
+
+func (t *Type) Nfields() int {
+ if t.List == nil {
+ return 0;
+ }
+ nx, nt := 0, 0;
+ for i, n := 0, t.List.Len(); i < n; i++ {
+ if dummy, ok := t.List.At(i).(*TypeLit); ok {
+ nt++;
+ } else {
+ nx++;
+ }
+ }
+ if nx == 0 {
+ return nt;
+ }
+ return nx;
+}
// ----------------------------------------------------------------------------
type Stat struct {
Node;
Init, Post *Stat;
- Expr *Expr;
+ Expr Expr;
Body *Block; // composite statement body
Decl *Decl; // declaration statement
}
type Decl struct {
Node;
- Ident *Expr; // nil for ()-style declarations
+ Ident Expr; // nil for ()-style declarations
Typ *Type;
- Val *Expr;
+ Val Expr;
+ Body *Block;
// list of *Decl for ()-style declarations
List *array.Array; End int;
}
type Program struct {
Pos int; // tok is Scanner.PACKAGE
- Ident *Expr;
+ Ident Expr;
Decls *array.Array;
Comments *array.Array;
}
func (P *Parser) PrintIndent() {
for i := P.indent; i > 0; i-- {
- print(". ");
+ fmt.Printf(". ");
}
}
func (P *Parser) Trace(msg string) {
- if P.verbose {
- P.PrintIndent();
- print(msg, " {\n");
- }
- P.indent++; // always check proper identation
+ P.PrintIndent();
+ fmt.Printf("%s {\n", msg);
+ P.indent++;
}
func (P *Parser) Ecart() {
- P.indent--; // always check proper identation
- if P.verbose {
- P.PrintIndent();
- print("}\n");
- }
+ P.indent--;
+ P.PrintIndent();
+ fmt.Printf("}\n");
}
case "{": s = "LBRACE";
case "}": s = "RBRACE";
}
- print("[", P.pos, "] ", s, "\n");
+ fmt.Printf("[%d] %s\n", P.pos, s);
}
}
}
-func (P *Parser) DeclareInScope(scope *AST.Scope, x *AST.Expr, kind int, typ *AST.Type) {
+func (P *Parser) DeclareInScope(scope *AST.Scope, x AST.Expr, kind int, typ *AST.Type) {
if P.scope_lev < 0 {
panic("cannot declare objects in other packages");
}
- if x.Tok != Scanner.ILLEGAL { // ignore bad exprs
- assert(x.Tok == Scanner.IDENT);
- obj := x.Obj;
+ if ident, ok := x.(*AST.Ident); ok { // ignore bad exprs
+ obj := ident.Obj;
obj.Kind = kind;
obj.Typ = typ;
obj.Pnolev = P.scope_lev;
// Declare a comma-separated list of idents or a single ident.
-func (P *Parser) Declare(p *AST.Expr, kind int, typ *AST.Type) {
- for p.Tok == Scanner.COMMA {
- P.DeclareInScope(P.top_scope, p.X, kind, typ);
- p = p.Y;
+func (P *Parser) Declare(x AST.Expr, kind int, typ *AST.Type) {
+ for {
+ p, ok := x.(*AST.BinaryExpr);
+ if ok && p.Tok == Scanner.COMMA {
+ P.DeclareInScope(P.top_scope, p.X, kind, typ);
+ x = p.Y;
+ } else {
+ break;
+ }
}
- P.DeclareInScope(P.top_scope, p, kind, typ);
+ P.DeclareInScope(P.top_scope, x, kind, typ);
}
// ----------------------------------------------------------------------------
// AST support
-func exprType(x *AST.Expr) *AST.Type {
- var t *AST.Type;
- if x.Tok == Scanner.TYPE {
- t = x.Typ;
- } else if x.Tok == Scanner.IDENT {
+func exprType(x AST.Expr) *AST.Type {
+ var typ *AST.Type;
+ if t, is_type := x.(*AST.TypeLit); is_type {
+ typ = t.Typ
+ } else if t, is_ident := x.(*AST.Ident); is_ident {
// assume a type name
- t = AST.NewType(x.Pos, AST.TYPENAME);
- t.Expr = x;
- } else if x.Tok == Scanner.PERIOD && x.Y != nil && exprType(x.X) != nil {
+ typ = AST.NewType(t.Pos(), AST.TYPENAME);
+ typ.Expr = x;
+ } else if t, is_selector := x.(*AST.Selector); is_selector && exprType(t.Sel) != nil {
// possibly a qualified (type) identifier
- t = AST.NewType(x.Pos, AST.TYPENAME);
- t.Expr = x;
+ typ = AST.NewType(t.Pos(), AST.TYPENAME);
+ typ.Expr = x;
}
- return t;
+ return typ;
}
-func (P *Parser) NoType(x *AST.Expr) *AST.Expr {
- if x != nil && x.Tok == Scanner.TYPE {
- P.Error(x.Pos, "expected expression, found type");
- val := AST.NewObject(x.Pos, AST.NONE, "0");
- x = AST.NewLit(Scanner.INT, val);
+func (P *Parser) NoType(x AST.Expr) AST.Expr {
+ if x != nil {
+ lit, ok := x.(*AST.TypeLit);
+ if ok {
+ P.Error(lit.Typ.Pos, "expected expression, found type");
+ x = &AST.BasicLit{lit.Typ.Pos, Scanner.STRING, ""};
+ }
}
return x;
}
-func (P *Parser) NewExpr(pos, tok int, x, y *AST.Expr) *AST.Expr {
- return AST.NewExpr(pos, tok, P.NoType(x), P.NoType(y));
+func (P *Parser) NewBinary(pos, tok int, x, y AST.Expr) *AST.BinaryExpr {
+ return &AST.BinaryExpr{pos, tok, P.NoType(x), P.NoType(y)};
}
// Common productions
func (P *Parser) TryType() *AST.Type;
-func (P *Parser) ParseExpression(prec int) *AST.Expr;
+func (P *Parser) ParseExpression(prec int) AST.Expr;
func (P *Parser) ParseStatement() *AST.Stat;
func (P *Parser) ParseDeclaration() *AST.Decl;
// If scope != nil, lookup identifier in scope. Otherwise create one.
-func (P *Parser) ParseIdent(scope *AST.Scope) *AST.Expr {
- P.Trace("Ident");
+func (P *Parser) ParseIdent(scope *AST.Scope) *AST.Ident {
+ if P.verbose {
+ P.Trace("Ident");
+ defer P.Ecart();
+ }
- x := AST.BadExpr;
if P.tok == Scanner.IDENT {
var obj *AST.Object;
if scope != nil {
} else {
assert(obj.Kind != AST.NONE);
}
- x = AST.NewLit(Scanner.IDENT, obj);
- x.Pos = P.pos; // override obj.pos (incorrect if object was looked up!)
+ x := &AST.Ident{P.pos, obj};
if P.verbose {
P.PrintIndent();
- print("Ident = \"", P.val, "\"\n");
+ fmt.Printf("ident = \"%s\"\n", P.val);
}
P.Next();
- } else {
- P.Expect(Scanner.IDENT); // use Expect() error handling
+ return x;
}
-
- P.Ecart();
- return x;
+
+ P.Expect(Scanner.IDENT); // use Expect() error handling
+ return &AST.Ident{P.pos, nil};
}
-func (P *Parser) ParseIdentList() *AST.Expr {
- P.Trace("IdentList");
+func (P *Parser) ParseIdentList() AST.Expr {
+ if P.verbose {
+ P.Trace("IdentList");
+ defer P.Ecart();
+ }
- var last *AST.Expr;
- x := P.ParseIdent(nil);
+ var last *AST.BinaryExpr;
+ var x AST.Expr = P.ParseIdent(nil);
for P.tok == Scanner.COMMA {
pos := P.pos;
P.Next();
y := P.ParseIdent(nil);
if last == nil {
- x = P.NewExpr(pos, Scanner.COMMA, x, y);
- last = x;
+ last = P.NewBinary(pos, Scanner.COMMA, x, y);
+ x = last;
} else {
- last.Y = P.NewExpr(pos, Scanner.COMMA, last.Y, y);
+ last.Y = P.NewBinary(pos, Scanner.COMMA, last.Y, y);
last = last.Y;
}
}
- P.Ecart();
return x;
}
// Types
func (P *Parser) ParseType() *AST.Type {
- P.Trace("Type");
+ if P.verbose {
+ P.Trace("Type");
+ defer P.Ecart();
+ }
t := P.TryType();
if t == nil {
t = AST.BadType;
}
- P.Ecart();
return t;
}
func (P *Parser) ParseVarType() *AST.Type {
- P.Trace("VarType");
-
- typ := P.ParseType();
+ if P.verbose {
+ P.Trace("VarType");
+ defer P.Ecart();
+ }
- P.Ecart();
- return typ;
+ return P.ParseType();
}
-func (P *Parser) ParseQualifiedIdent() *AST.Expr {
- P.Trace("QualifiedIdent");
+func (P *Parser) ParseQualifiedIdent() AST.Expr {
+ if P.verbose {
+ P.Trace("QualifiedIdent");
+ defer P.Ecart();
+ }
- x := P.ParseIdent(P.top_scope);
+ var x AST.Expr = P.ParseIdent(P.top_scope);
for P.tok == Scanner.PERIOD {
pos := P.pos;
P.Next();
y := P.ParseIdent(nil);
- x = P.NewExpr(pos, Scanner.PERIOD, x, y);
+ x = &AST.Selector{pos, x, y};
}
- P.Ecart();
return x;
}
func (P *Parser) ParseTypeName() *AST.Type {
- P.Trace("TypeName");
+ if P.verbose {
+ P.Trace("TypeName");
+ defer P.Ecart();
+ }
t := AST.NewType(P.pos, AST.TYPENAME);
t.Expr = P.ParseQualifiedIdent();
- t.Elt = t.Expr.Typ;
- P.Ecart();
return t;
}
func (P *Parser) ParseArrayType() *AST.Type {
- P.Trace("ArrayType");
+ if P.verbose {
+ P.Trace("ArrayType");
+ defer P.Ecart();
+ }
t := AST.NewType(P.pos, AST.ARRAY);
P.Expect(Scanner.LBRACK);
if P.tok == Scanner.ELLIPSIS {
- t.Expr = P.NewExpr(P.pos, Scanner.ELLIPSIS, nil, nil);
+ t.Expr = P.NewBinary(P.pos, Scanner.ELLIPSIS, nil, nil);
P.Next();
} else if P.tok != Scanner.RBRACK {
t.Expr = P.ParseExpression(1);
P.Expect(Scanner.RBRACK);
t.Elt = P.ParseType();
- P.Ecart();
return t;
}
func (P *Parser) ParseChannelType() *AST.Type {
- P.Trace("ChannelType");
+ if P.verbose {
+ P.Trace("ChannelType");
+ defer P.Ecart();
+ }
t := AST.NewType(P.pos, AST.CHANNEL);
t.Mode = AST.FULL;
}
t.Elt = P.ParseVarType();
- P.Ecart();
return t;
}
t := AST.BadType;
if expect_ident {
x := P.ParseIdent(nil);
- t = AST.NewType(x.Pos, AST.TYPENAME);
+ t = AST.NewType(x.Pos(), AST.TYPENAME);
t.Expr = x;
} else if P.tok == Scanner.ELLIPSIS {
t = AST.NewType(P.pos, AST.ELLIPSIS);
func (P *Parser) ParseVarList(list *array.Array, ellipsis_ok bool) {
- P.Trace("VarList");
+ if P.verbose {
+ P.Trace("VarList");
+ defer P.Ecart();
+ }
// assume a list of types
// (a list of identifiers looks like a list of type names)
// convert the type entries into identifiers
for i, n := i0, list.Len(); i < n; i++ {
t := list.At(i).(*AST.Type);
- if t.Form == AST.TYPENAME && t.Expr.Tok == Scanner.IDENT {
- list.Set(i, t.Expr);
- } else {
- list.Set(i, AST.BadExpr);
- P.Error(t.Pos, "identifier expected");
+ if t.Form == AST.TYPENAME {
+ if ident, ok := t.Expr.(*AST.Ident); ok {
+ list.Set(i, ident);
+ continue;
+ }
}
+ list.Set(i, &AST.BadExpr{0});
+ P.Error(t.Pos, "identifier expected");
}
// add type
- list.Push(AST.NewTypeExpr(typ));
+ list.Push(&AST.TypeLit{typ});
} else {
// all list entries are types
// convert all type entries into type expressions
for i, n := i0, list.Len(); i < n; i++ {
t := list.At(i).(*AST.Type);
- list.Set(i, AST.NewTypeExpr(t));
+ list.Set(i, &AST.TypeLit{t});
}
}
-
- P.Ecart();
}
func (P *Parser) ParseParameterList(ellipsis_ok bool) *array.Array {
- P.Trace("ParameterList");
+ if P.verbose {
+ P.Trace("ParameterList");
+ defer P.Ecart();
+ }
list := array.New(0);
P.ParseVarList(list, ellipsis_ok);
P.ParseVarList(list, ellipsis_ok);
}
- P.Ecart();
return list;
}
func (P *Parser) ParseParameters(ellipsis_ok bool) *AST.Type {
- P.Trace("Parameters");
+ if P.verbose {
+ P.Trace("Parameters");
+ defer P.Ecart();
+ }
t := AST.NewType(P.pos, AST.STRUCT);
P.Expect(Scanner.LPAREN);
t.End = P.pos;
P.Expect(Scanner.RPAREN);
- P.Ecart();
return t;
}
func (P *Parser) ParseResultList() {
- P.Trace("ResultList");
+ if P.verbose {
+ P.Trace("ResultList");
+ defer P.Ecart();
+ }
P.ParseType();
for P.tok == Scanner.COMMA {
if P.tok != Scanner.RPAREN {
P.ParseType();
}
-
- P.Ecart();
}
func (P *Parser) ParseResult(ftyp *AST.Type) *AST.Type {
- P.Trace("Result");
+ if P.verbose {
+ P.Trace("Result");
+ defer P.Ecart();
+ }
var t *AST.Type;
if P.tok == Scanner.LPAREN {
if typ != nil {
t = AST.NewType(P.pos, AST.STRUCT);
t.List = array.New(0);
- t.List.Push(AST.NewTypeExpr(typ));
+ t.List.Push(&AST.TypeLit{typ});
t.End = P.pos;
}
}
- P.Ecart();
return t;
}
// (params) (results)
func (P *Parser) ParseSignature() *AST.Type {
- P.Trace("Signature");
+ if P.verbose {
+ P.Trace("Signature");
+ defer P.Ecart();
+ }
P.OpenScope();
P.scope_lev++;
P.scope_lev--;
P.CloseScope();
- P.Ecart();
return t;
}
func (P *Parser) ParseFunctionType() *AST.Type {
- P.Trace("FunctionType");
+ if P.verbose {
+ P.Trace("FunctionType");
+ defer P.Ecart();
+ }
P.Expect(Scanner.FUNC);
- t := P.ParseSignature();
-
- P.Ecart();
- return t;
+ return P.ParseSignature();
}
func (P *Parser) ParseMethodSpec(list *array.Array) {
- P.Trace("MethodDecl");
+ if P.verbose {
+ P.Trace("MethodDecl");
+ defer P.Ecart();
+ }
list.Push(P.ParseIdentList());
t := P.ParseSignature();
- list.Push(AST.NewTypeExpr(t));
-
- P.Ecart();
+ list.Push(&AST.TypeLit{t});
}
func (P *Parser) ParseInterfaceType() *AST.Type {
- P.Trace("InterfaceType");
+ if P.verbose {
+ P.Trace("InterfaceType");
+ defer P.Ecart();
+ }
t := AST.NewType(P.pos, AST.INTERFACE);
P.Expect(Scanner.INTERFACE);
P.Expect(Scanner.RBRACE);
}
- P.Ecart();
return t;
}
func (P *Parser) ParseMapType() *AST.Type {
- P.Trace("MapType");
+ if P.verbose {
+ P.Trace("MapType");
+ defer P.Ecart();
+ }
t := AST.NewType(P.pos, AST.MAP);
P.Expect(Scanner.MAP);
P.Expect(Scanner.RBRACK);
t.Elt = P.ParseVarType();
- P.Ecart();
return t;
}
-func (P *Parser) ParseOperand() *AST.Expr
+func (P *Parser) ParseOperand() AST.Expr
func (P *Parser) ParseStructType() *AST.Type {
- P.Trace("StructType");
+ if P.verbose {
+ P.Trace("StructType");
+ defer P.Ecart();
+ }
t := AST.NewType(P.pos, AST.STRUCT);
P.Expect(Scanner.STRUCT);
// enter fields into struct scope
for i, n := 0, t.List.Len(); i < n; i++ {
- x := t.List.At(i).(*AST.Expr);
- if x.Tok == Scanner.IDENT {
+ if x, ok := t.List.At(i).(*AST.Ident); ok {
P.DeclareInScope(t.Scope, x, AST.FIELD, nil);
}
}
}
- P.Ecart();
return t;
}
func (P *Parser) ParsePointerType() *AST.Type {
- P.Trace("PointerType");
+ if P.verbose {
+ P.Trace("PointerType");
+ defer P.Ecart();
+ }
t := AST.NewType(P.pos, AST.POINTER);
P.Expect(Scanner.MUL);
t.Elt = P.ParseType();
- P.Ecart();
return t;
}
func (P *Parser) TryType() *AST.Type {
- P.Trace("Type (try)");
+ if P.verbose {
+ P.Trace("Type (try)");
+ defer P.Ecart();
+ }
t := AST.BadType;
switch P.tok {
case Scanner.MUL: t = P.ParsePointerType();
default: t = nil; // no type found
}
-
- P.Ecart();
return t;
}
// Blocks
func (P *Parser) ParseStatementList(list *array.Array) {
- P.Trace("StatementList");
+ if P.verbose {
+ P.Trace("StatementList");
+ defer P.Ecart();
+ }
for P.tok != Scanner.CASE && P.tok != Scanner.DEFAULT && P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
s := P.ParseStatement();
if P.tok != Scanner.CASE && P.tok != Scanner.DEFAULT && P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
P.Error(P.pos, "expected end of statement list (semicolon missing?)");
}
-
- P.Ecart();
}
func (P *Parser) ParseBlock(ftyp *AST.Type, tok int) *AST.Block {
- P.Trace("Block");
+ if P.verbose {
+ P.Trace("Block");
+ defer P.Ecart();
+ }
b := AST.NewBlock(P.pos, tok);
P.Expect(tok);
}
if ftyp.List != nil {
for i, n := 0, ftyp.List.Len(); i < n; i++ {
- x := ftyp.List.At(i).(*AST.Expr);
- if x.Tok == Scanner.IDENT {
+ if x, ok := ftyp.List.At(i).(*AST.Ident); ok {
P.DeclareInScope(P.top_scope, x, AST.VAR, nil);
}
}
P.opt_semi = true;
}
- P.Ecart();
return b;
}
// ----------------------------------------------------------------------------
// Expressions
-func (P *Parser) ParseExpressionList() *AST.Expr {
- P.Trace("ExpressionList");
+func (P *Parser) ParseExpressionList() AST.Expr {
+ if P.verbose {
+ P.Trace("ExpressionList");
+ defer P.Ecart();
+ }
x := P.ParseExpression(1);
for first := true; P.tok == Scanner.COMMA; {
P.Next();
y := P.ParseExpression(1);
if first {
- x = P.NewExpr(pos, Scanner.COMMA, x, y);
+ x = P.NewBinary(pos, Scanner.COMMA, x, y);
first = false;
} else {
- x.Y = P.NewExpr(pos, Scanner.COMMA, x.Y, y);
+ x.(*AST.BinaryExpr).Y = P.NewBinary(pos, Scanner.COMMA, x.(*AST.BinaryExpr).Y, y);
}
}
- P.Ecart();
return x;
}
-func (P *Parser) ParseFunctionLit() *AST.Expr {
- P.Trace("FunctionLit");
+func (P *Parser) ParseFunctionLit() AST.Expr {
+ if P.verbose {
+ P.Trace("FunctionLit");
+ defer P.Ecart();
+ }
- f := AST.NewObject(P.pos, AST.FUNC, "");
+ pos := P.pos;
P.Expect(Scanner.FUNC);
- f.Typ = P.ParseSignature();
+ typ := P.ParseSignature();
P.expr_lev++;
P.scope_lev++;
- f.Body = P.ParseBlock(f.Typ, Scanner.LBRACE);
+ body := P.ParseBlock(typ, Scanner.LBRACE);
P.scope_lev--;
P.expr_lev--;
- P.Ecart();
- return AST.NewLit(Scanner.FUNC, f);
+ return &AST.FunctionLit{pos, typ, body};
}
-func (P *Parser) ParseOperand() *AST.Expr {
- P.Trace("Operand");
+func (P *Parser) ParseOperand() AST.Expr {
+ if P.verbose {
+ P.Trace("Operand");
+ defer P.Ecart();
+ }
- x := AST.BadExpr;
switch P.tok {
case Scanner.IDENT:
- x = P.ParseIdent(P.top_scope);
+ return P.ParseIdent(P.top_scope);
case Scanner.LPAREN:
// TODO we could have a function type here as in: new(())
// (currently not working)
P.Next();
P.expr_lev++;
- x = P.ParseExpression(1);
+ x := P.ParseExpression(1);
P.expr_lev--;
P.Expect(Scanner.RPAREN);
+ return x;
case Scanner.INT, Scanner.FLOAT, Scanner.STRING:
- val := AST.NewObject(P.pos, AST.NONE, P.val);
- x = AST.NewLit(P.tok, val);
+ x := &AST.BasicLit{P.pos, P.tok, P.val};
P.Next();
if x.Tok == Scanner.STRING {
// TODO should remember the list instead of
// concatenate the strings here
for ; P.tok == Scanner.STRING; P.Next() {
- x.Obj.Ident += P.val;
+ x.Val += P.val;
}
}
+ return x;
case Scanner.FUNC:
- x = P.ParseFunctionLit();
+ return P.ParseFunctionLit();
default:
t := P.TryType();
if t != nil {
- x = AST.NewTypeExpr(t);
+ return &AST.TypeLit{t};
} else {
P.Error(P.pos, "operand expected");
P.Next(); // make progress
}
}
- P.Ecart();
- return x;
+ return &AST.BadExpr{P.pos};
}
-func (P *Parser) ParseSelectorOrTypeGuard(x *AST.Expr) *AST.Expr {
- P.Trace("SelectorOrTypeGuard");
+func (P *Parser) ParseSelectorOrTypeGuard(x AST.Expr) AST.Expr {
+ if P.verbose {
+ P.Trace("SelectorOrTypeGuard");
+ defer P.Ecart();
+ }
- x = P.NewExpr(P.pos, Scanner.PERIOD, x, nil);
+ pos := P.pos;
P.Expect(Scanner.PERIOD);
if P.tok == Scanner.IDENT {
- // TODO should always guarantee x.Typ != nil
- var scope *AST.Scope;
- if x.X.Typ != nil {
- scope = x.X.Typ.Scope;
- }
- x.Y = P.ParseIdent(scope);
- x.Typ = x.Y.Obj.Typ;
+ x = &AST.Selector{pos, x, P.ParseIdent(nil)};
} else {
P.Expect(Scanner.LPAREN);
- x.Y = AST.NewTypeExpr(P.ParseType());
- x.Typ = x.Y.Typ;
+ x = &AST.TypeGuard{pos, x, P.ParseType()};
P.Expect(Scanner.RPAREN);
}
- P.Ecart();
return x;
}
-func (P *Parser) ParseIndex(x *AST.Expr) *AST.Expr {
- P.Trace("IndexOrSlice");
+func (P *Parser) ParseIndex(x AST.Expr) AST.Expr {
+ if P.verbose {
+ P.Trace("IndexOrSlice");
+ defer P.Ecart();
+ }
pos := P.pos;
P.Expect(Scanner.LBRACK);
P.expr_lev--;
P.Expect(Scanner.RBRACK);
- P.Ecart();
- return P.NewExpr(pos, Scanner.LBRACK, x, i);
+ return &AST.Index{pos, x, i};
}
-func (P *Parser) ParseBinaryExpr(prec1 int) *AST.Expr
+func (P *Parser) ParseBinaryExpr(prec1 int) AST.Expr
-func (P *Parser) ParseCall(x0 *AST.Expr) *AST.Expr {
- P.Trace("Call");
+func (P *Parser) ParseCall(f AST.Expr) AST.Expr {
+ if P.verbose {
+ P.Trace("Call");
+ defer P.Ecart();
+ }
- x := P.NewExpr(P.pos, Scanner.LPAREN, x0, nil);
+ call := &AST.Call{P.pos, f, nil};
P.Expect(Scanner.LPAREN);
if P.tok != Scanner.RPAREN {
P.expr_lev++;
var t *AST.Type;
- if x0.Tok == Scanner.IDENT && (x0.Obj.Ident == "new" || x0.Obj.Ident == "make") {
+ if x0, ok := f.(*AST.Ident); ok && (x0.Obj.Ident == "new" || x0.Obj.Ident == "make") {
// heuristic: assume it's a new(T) or make(T, ...) call, try to parse a type
t = P.TryType();
}
if t != nil {
// we found a type
- x.Y = AST.NewTypeExpr(t);
+ args := &AST.TypeLit{t};
if P.tok == Scanner.COMMA {
pos := P.pos;
P.Next();
y := P.ParseExpressionList();
// create list manually because NewExpr checks for type expressions
- z := AST.NewExpr(pos, Scanner.COMMA, nil, y);
- z.X = x.Y;
- x.Y = z;
+ args := &AST.BinaryExpr{pos, Scanner.COMMA, args, y};
}
+ call.Args = args;
} else {
// normal argument list
- x.Y = P.ParseExpressionList();
+ call.Args = P.ParseExpressionList();
}
P.expr_lev--;
}
P.Expect(Scanner.RPAREN);
- P.Ecart();
- return x;
+ return call;
}
-func (P *Parser) ParseCompositeElements() *AST.Expr {
+func (P *Parser) ParseCompositeElements() AST.Expr {
x := P.ParseExpression(0);
if P.tok == Scanner.COMMA {
pos := P.pos;
// first element determines mode
singles := true;
- if x.Tok == Scanner.COLON {
+ if t, is_binary := x.(*AST.BinaryExpr); is_binary && t.Tok == Scanner.COLON {
singles = false;
}
- var last *AST.Expr;
+ var last *AST.BinaryExpr;
for P.tok != Scanner.RBRACE && P.tok != Scanner.EOF {
y := P.ParseExpression(0);
if singles {
- if y.Tok == Scanner.COLON {
- P.Error(y.X.Pos, "single value expected; found pair");
+ if t, is_binary := y.(*AST.BinaryExpr); is_binary && t.Tok == Scanner.COLON {
+ P.Error(t.X.Pos(), "single value expected; found pair");
}
} else {
- if y.Tok != Scanner.COLON {
- P.Error(y.Pos, "key:value pair expected; found single value");
+ if t, is_binary := y.(*AST.BinaryExpr); !is_binary || t.Tok != Scanner.COLON {
+ P.Error(y.Pos(), "key:value pair expected; found single value");
}
}
if last == nil {
- x = P.NewExpr(pos, Scanner.COMMA, x, y);
- last = x;
+ last = P.NewBinary(pos, Scanner.COMMA, x, y);
+ x = last;
} else {
- last.Y = P.NewExpr(pos, Scanner.COMMA, last.Y, y);
+ last.Y = P.NewBinary(pos, Scanner.COMMA, last.Y, y);
last = last.Y;
}
}
-func (P *Parser) ParseCompositeLit(t *AST.Type) *AST.Expr {
- P.Trace("CompositeLit");
+func (P *Parser) ParseCompositeLit(t *AST.Type) AST.Expr {
+ if P.verbose {
+ P.Trace("CompositeLit");
+ defer P.Ecart();
+ }
- x := P.NewExpr(P.pos, Scanner.LBRACE, nil, nil);
- x.Obj = AST.NewObject(t.Pos, AST.TYPE, "");
- x.Obj.Typ = t;
+ pos := P.pos;
P.Expect(Scanner.LBRACE);
+ var elts AST.Expr;
if P.tok != Scanner.RBRACE {
- x.Y = P.ParseCompositeElements();
+ elts = P.ParseCompositeElements();
}
P.Expect(Scanner.RBRACE);
- P.Ecart();
- return x;
+ return &AST.CompositeLit{pos, t, elts};
}
-func (P *Parser) ParsePrimaryExpr() *AST.Expr {
- P.Trace("PrimaryExpr");
+func (P *Parser) ParsePrimaryExpr() AST.Expr {
+ if P.verbose {
+ P.Trace("PrimaryExpr");
+ defer P.Ecart();
+ }
x := P.ParseOperand();
for {
if t != nil {
x = P.ParseCompositeLit(t);
} else {
- goto exit;
+ return x;
}
- default: goto exit;
+ default:
+ return x;
}
}
-exit:
- P.Ecart();
- return x;
+ unreachable();
+ return nil;
}
-func (P *Parser) ParseUnaryExpr() *AST.Expr {
- P.Trace("UnaryExpr");
+func (P *Parser) ParseUnaryExpr() AST.Expr {
+ if P.verbose {
+ P.Trace("UnaryExpr");
+ defer P.Ecart();
+ }
- x := AST.BadExpr;
switch P.tok {
case Scanner.ADD, Scanner.SUB, Scanner.MUL, Scanner.NOT, Scanner.XOR, Scanner.ARROW, Scanner.AND:
pos, tok := P.pos, P.tok;
P.Next();
y := P.ParseUnaryExpr();
- if tok == Scanner.MUL && y.Tok == Scanner.TYPE {
+ if lit, ok := y.(*AST.TypeLit); ok && tok == Scanner.MUL {
// pointer type
t := AST.NewType(pos, AST.POINTER);
- t.Elt = y.Obj.Typ;
- x = AST.NewTypeExpr(t);
+ t.Elt = lit.Typ;
+ return &AST.TypeLit{t};
} else {
- x = P.NewExpr(pos, tok, nil, y);
+ return &AST.UnaryExpr{pos, tok, y};
}
-
- default:
- x = P.ParsePrimaryExpr();
}
- P.Ecart();
- return x;
+ return P.ParsePrimaryExpr();
}
-func (P *Parser) ParseBinaryExpr(prec1 int) *AST.Expr {
- P.Trace("BinaryExpr");
+func (P *Parser) ParseBinaryExpr(prec1 int) AST.Expr {
+ if P.verbose {
+ P.Trace("BinaryExpr");
+ defer P.Ecart();
+ }
x := P.ParseUnaryExpr();
for prec := Scanner.Precedence(P.tok); prec >= prec1; prec-- {
pos, tok := P.pos, P.tok;
P.Next();
y := P.ParseBinaryExpr(prec + 1);
- x = P.NewExpr(pos, tok, x, y);
+ x = P.NewBinary(pos, tok, x, y);
}
}
- P.Ecart();
return x;
}
-func (P *Parser) ParseExpression(prec int) *AST.Expr {
- P.Trace("Expression");
- indent := P.indent;
+func (P *Parser) ParseExpression(prec int) AST.Expr {
+ if P.verbose {
+ P.Trace("Expression");
+ defer P.Ecart();
+ }
+ indent := P.indent;
if prec < 0 {
panic("precedence must be >= 0");
}
x := P.NoType(P.ParseBinaryExpr(prec));
-
if indent != P.indent {
panic("imbalanced tracing code (Expression)");
}
- P.Ecart();
+
return x;
}
// Statements
func (P *Parser) ParseSimpleStat(range_ok bool) *AST.Stat {
- P.Trace("SimpleStat");
+ if P.verbose {
+ P.Trace("SimpleStat");
+ defer P.Ecart();
+ }
s := AST.BadStat;
x := P.ParseExpressionList();
- is_range := false;
- if range_ok && P.tok == Scanner.COLON {
- pos := P.pos;
- P.Next();
- y := P.ParseExpression(1);
- if x.Len() == 1 {
- x = P.NewExpr(pos, Scanner.COLON, x, y);
- is_range = true;
- } else {
- P.Error(pos, "expected initialization, found ':'");
- }
- }
-
switch P.tok {
case Scanner.COLON:
// label declaration
s = AST.NewStat(P.pos, Scanner.COLON);
s.Expr = x;
- if x.Len() != 1 {
- P.Error(x.Pos, "illegal label declaration");
+ if AST.ExprLen(x) != 1 {
+ P.Error(x.Pos(), "illegal label declaration");
}
P.Next(); // consume ":"
P.opt_semi = true;
-
+
case
Scanner.DEFINE, Scanner.ASSIGN, Scanner.ADD_ASSIGN,
Scanner.SUB_ASSIGN, Scanner.MUL_ASSIGN, Scanner.QUO_ASSIGN,
// declaration/assignment
pos, tok := P.pos, P.tok;
P.Next();
- y := AST.BadExpr;
+ var y AST.Expr = &AST.BadExpr{pos};
if P.tok == Scanner.RANGE {
range_pos := P.pos;
P.Next();
y = P.ParseExpression(1);
- y = P.NewExpr(range_pos, Scanner.RANGE, nil, y);
+ y = P.NewBinary(range_pos, Scanner.RANGE, nil, y);
if tok != Scanner.DEFINE && tok != Scanner.ASSIGN {
P.Error(pos, "expected '=' or ':=', found '" + Scanner.TokenString(tok) + "'");
}
} else {
y = P.ParseExpressionList();
- if is_range {
- P.Error(y.Pos, "expected 'range', found expression");
- }
- if xl, yl := x.Len(), y.Len(); xl > 1 && yl > 1 && xl != yl {
- P.Error(x.Pos, "arity of lhs doesn't match rhs");
+ if xl, yl := AST.ExprLen(x), AST.ExprLen(y); xl > 1 && yl > 1 && xl != yl {
+ P.Error(x.Pos(), "arity of lhs doesn't match rhs");
}
}
- s = AST.NewStat(x.Pos, Scanner.EXPRSTAT);
- s.Expr = AST.NewExpr(pos, tok, x, y);
-
+ s = AST.NewStat(x.Pos(), Scanner.EXPRSTAT);
+ s.Expr = P.NewBinary(pos, tok, x, y);
+
case Scanner.RANGE:
pos := P.pos;
P.Next();
y := P.ParseExpression(1);
- y = P.NewExpr(pos, Scanner.RANGE, nil, y);
- s = AST.NewStat(x.Pos, Scanner.EXPRSTAT);
- s.Expr = AST.NewExpr(pos, Scanner.DEFINE, x, y);
+ y = &AST.UnaryExpr{pos, Scanner.RANGE, y};
+ s = AST.NewStat(x.Pos(), Scanner.EXPRSTAT);
+ s.Expr = P.NewBinary(pos, Scanner.DEFINE, x, y);
default:
var pos, tok int;
pos, tok = P.pos, P.tok;
P.Next();
} else {
- pos, tok = x.Pos, Scanner.EXPRSTAT;
+ pos, tok = x.Pos(), Scanner.EXPRSTAT;
}
s = AST.NewStat(pos, tok);
s.Expr = x;
- if x.Len() != 1 {
- P.Error(x.Pos, "only one expression allowed");
+ if AST.ExprLen(x) != 1 {
+ P.Error(pos, "only one expression allowed");
+ panic(); // fix position
}
}
- P.Ecart();
return s;
}
func (P *Parser) ParseInvocationStat(keyword int) *AST.Stat {
- P.Trace("InvocationStat");
+ if P.verbose {
+ P.Trace("InvocationStat");
+ defer P.Ecart();
+ }
s := AST.NewStat(P.pos, keyword);
P.Expect(keyword);
s.Expr = P.ParseExpression(1);
- P.Ecart();
return s;
}
func (P *Parser) ParseReturnStat() *AST.Stat {
- P.Trace("ReturnStat");
+ if P.verbose {
+ P.Trace("ReturnStat");
+ defer P.Ecart();
+ }
s := AST.NewStat(P.pos, Scanner.RETURN);
P.Expect(Scanner.RETURN);
s.Expr = P.ParseExpressionList();
}
- P.Ecart();
return s;
}
func (P *Parser) ParseControlFlowStat(tok int) *AST.Stat {
- P.Trace("ControlFlowStat");
+ if P.verbose {
+ P.Trace("ControlFlowStat");
+ defer P.Ecart();
+ }
s := AST.NewStat(P.pos, tok);
P.Expect(tok);
s.Expr = P.ParseIdent(P.top_scope);
}
- P.Ecart();
return s;
}
func (P *Parser) ParseControlClause(keyword int) *AST.Stat {
- P.Trace("ControlClause");
+ if P.verbose {
+ P.Trace("ControlClause");
+ defer P.Ecart();
+ }
s := AST.NewStat(P.pos, keyword);
P.Expect(keyword);
P.expr_lev = prev_lev;
}
- P.Ecart();
return s;
}
func (P *Parser) ParseIfStat() *AST.Stat {
- P.Trace("IfStat");
+ if P.verbose {
+ P.Trace("IfStat");
+ defer P.Ecart();
+ }
P.OpenScope();
s := P.ParseControlClause(Scanner.IF);
}
P.CloseScope();
- P.Ecart();
return s;
}
func (P *Parser) ParseForStat() *AST.Stat {
- P.Trace("ForStat");
+ if P.verbose {
+ P.Trace("ForStat");
+ defer P.Ecart();
+ }
P.OpenScope();
s := P.ParseControlClause(Scanner.FOR);
s.Body = P.ParseBlock(nil, Scanner.LBRACE);
P.CloseScope();
- P.Ecart();
return s;
}
func (P *Parser) ParseSwitchCase() *AST.Stat {
- P.Trace("SwitchCase");
+ if P.verbose {
+ P.Trace("SwitchCase");
+ defer P.Ecart();
+ }
s := AST.NewStat(P.pos, P.tok);
if P.tok == Scanner.CASE {
P.Expect(Scanner.DEFAULT);
}
- P.Ecart();
return s;
}
func (P *Parser) ParseCaseClause() *AST.Stat {
- P.Trace("CaseClause");
+ if P.verbose {
+ P.Trace("CaseClause");
+ defer P.Ecart();
+ }
s := P.ParseSwitchCase();
s.Body = P.ParseBlock(nil, Scanner.COLON);
- P.Ecart();
return s;
}
func (P *Parser) ParseSwitchStat() *AST.Stat {
- P.Trace("SwitchStat");
+ if P.verbose {
+ P.Trace("SwitchStat");
+ defer P.Ecart();
+ }
P.OpenScope();
s := P.ParseControlClause(Scanner.SWITCH);
P.CloseScope();
s.Body = b;
- P.Ecart();
return s;
}
func (P *Parser) ParseCommCase() *AST.Stat {
- P.Trace("CommCase");
+ if P.verbose {
+ P.Trace("CommCase");
+ defer P.Ecart();
+ }
s := AST.NewStat(P.pos, P.tok);
if P.tok == Scanner.CASE {
P.Next();
if P.tok == Scanner.ARROW {
y := P.ParseExpression(1);
- x = AST.NewExpr(pos, tok, x, y);
+ x = P.NewBinary(pos, tok, x, y);
} else {
P.Expect(Scanner.ARROW); // use Expect() error handling
}
P.Expect(Scanner.DEFAULT);
}
- P.Ecart();
return s;
}
func (P *Parser) ParseCommClause() *AST.Stat {
- P.Trace("CommClause");
+ if P.verbose {
+ P.Trace("CommClause");
+ defer P.Ecart();
+ }
s := P.ParseCommCase();
s.Body = P.ParseBlock(nil, Scanner.COLON);
- P.Ecart();
return s;
}
func (P *Parser) ParseSelectStat() *AST.Stat {
- P.Trace("SelectStat");
+ if P.verbose {
+ P.Trace("SelectStat");
+ defer P.Ecart();
+ }
s := AST.NewStat(P.pos, Scanner.SELECT);
P.Expect(Scanner.SELECT);
P.opt_semi = true;
s.Body = b;
- P.Ecart();
return s;
}
func (P *Parser) ParseStatement() *AST.Stat {
- P.Trace("Statement");
+ if P.verbose {
+ P.Trace("Statement");
+ defer P.Ecart();
+ }
indent := P.indent;
s := AST.BadStat;
if indent != P.indent {
panic("imbalanced tracing code (Statement)");
}
- P.Ecart();
return s;
}
// Declarations
func (P *Parser) ParseImportSpec(d *AST.Decl) {
- P.Trace("ImportSpec");
+ if P.verbose {
+ P.Trace("ImportSpec");
+ defer P.Ecart();
+ }
if P.tok == Scanner.PERIOD {
P.Error(P.pos, `"import ." not yet handled properly`);
if P.tok == Scanner.STRING {
// TODO eventually the scanner should strip the quotes
- val := AST.NewObject(P.pos, AST.NONE, P.val);
- d.Val = AST.NewLit(Scanner.STRING, val);
+ d.Val = &AST.BasicLit{P.pos, Scanner.STRING, P.val};
P.Next();
} else {
P.Expect(Scanner.STRING); // use Expect() error handling
}
-
- P.Ecart();
}
func (P *Parser) ParseConstSpec(d *AST.Decl) {
- P.Trace("ConstSpec");
+ if P.verbose {
+ P.Trace("ConstSpec");
+ defer P.Ecart();
+ }
d.Ident = P.ParseIdentList();
d.Typ = P.TryType();
P.Next();
d.Val = P.ParseExpressionList();
}
-
- P.Ecart();
}
func (P *Parser) ParseTypeSpec(d *AST.Decl) {
- P.Trace("TypeSpec");
+ if P.verbose {
+ P.Trace("TypeSpec");
+ defer P.Ecart();
+ }
d.Ident = P.ParseIdent(nil);
d.Typ = P.ParseType();
P.opt_semi = true;
-
- P.Ecart();
}
func (P *Parser) ParseVarSpec(d *AST.Decl) {
- P.Trace("VarSpec");
+ if P.verbose {
+ P.Trace("VarSpec");
+ defer P.Ecart();
+ }
d.Ident = P.ParseIdentList();
if P.tok == Scanner.ASSIGN {
d.Val = P.ParseExpressionList();
}
}
-
- P.Ecart();
}
P.Declare(d.Ident, kind, d.Typ);
if d.Val != nil {
// initialization/assignment
- llen := d.Ident.Len();
- rlen := d.Val.Len();
+ llen := AST.ExprLen(d.Ident);
+ rlen := AST.ExprLen(d.Val);
if llen == rlen {
// TODO
} else if rlen == 1 {
// TODO
} else {
if llen < rlen {
- P.Error(d.Val.At(llen).Pos, "more expressions than variables");
+ P.Error(AST.ExprAt(d.Val, llen).Pos(), "more expressions than variables");
} else {
- P.Error(d.Ident.At(rlen).Pos, "more variables than expressions");
+ P.Error(AST.ExprAt(d.Ident, rlen).Pos(), "more variables than expressions");
}
}
} else {
func (P *Parser) ParseDecl(keyword int) *AST.Decl {
- P.Trace("Decl");
+ if P.verbose {
+ P.Trace("Decl");
+ defer P.Ecart();
+ }
d := AST.NewDecl(P.pos, keyword);
P.Expect(keyword);
P.ParseSpec(d);
}
- P.Ecart();
return d;
}
// func (recv) ident (params) (results)
func (P *Parser) ParseFunctionDecl() *AST.Decl {
- P.Trace("FunctionDecl");
+ if P.verbose {
+ P.Trace("FunctionDecl");
+ defer P.Ecart();
+ }
d := AST.NewDecl(P.pos, Scanner.FUNC);
P.Expect(Scanner.FUNC);
}
}
- d.Ident = P.ParseIdent(nil);
+ ident := P.ParseIdent(nil);
+ d.Ident = ident;
d.Typ = P.ParseSignature();
d.Typ.Key = recv;
if P.tok == Scanner.LBRACE {
- f := AST.NewObject(d.Pos, AST.FUNC, d.Ident.Obj.Ident);
- f.Typ = d.Typ;
- f.Body = P.ParseBlock(d.Typ, Scanner.LBRACE);
- d.Val = AST.NewLit(Scanner.FUNC, f);
+ d.Body = P.ParseBlock(d.Typ, Scanner.LBRACE);
}
- P.Ecart();
return d;
}
func (P *Parser) ParseDeclaration() *AST.Decl {
- P.Trace("Declaration");
+ if P.verbose {
+ P.Trace("Declaration");
+ defer P.Ecart();
+ }
indent := P.indent;
d := AST.BadDecl;
if indent != P.indent {
panic("imbalanced tracing code (Declaration)");
}
- P.Ecart();
return d;
}
// Program
func (P *Parser) ParseProgram() *AST.Program {
- P.Trace("Program");
+ if P.verbose {
+ P.Trace("Program");
+ defer P.Ecart();
+ }
P.OpenScope();
p := AST.NewProgram(P.pos);
p.Comments = P.comments;
P.CloseScope();
- P.Ecart();
return p;
}
)
+// ----------------------------------------------------------------------------
+// Elementary support
+
+func unimplemented() {
+ panic("unimplemented");
+}
+
+
+func unreachable() {
+ panic("unreachable");
+}
+
+
+func assert(pred bool) {
+ if !pred {
+ panic("assertion failed");
+ }
+}
+
+
// ----------------------------------------------------------------------------
// Printer
// semantic state
state int; // current semantic state
laststate int; // state for last string
+
+ // expression precedence
+ prec int;
}
P.NextComment();
// formatting parameters & semantic state initialized correctly by default
+
+ // expression precedence
+ P.prec = Scanner.LowestPrec;
}
}
-func (P *Printer) HtmlIdentifier(x *AST.Expr) {
- if x.Tok != Scanner.IDENT {
- panic();
- }
+func (P *Printer) HtmlIdentifier(x *AST.Ident) {
obj := x.Obj;
if *html && obj.Kind != AST.NONE {
// depending on whether we have a declaration or use, generate different html
// - no need to htmlEscape ident
id := Utils.IntToString(obj.Id, 10);
- if x.Pos == obj.Pos {
+ if x.Pos() == obj.Pos {
// probably the declaration of x
- P.TaggedString(x.Pos, `<a name="id` + id + `">`, obj.Ident, `</a>`);
+ P.TaggedString(x.Pos
(), `<a name="id` + id + `">`, obj.Ident, `</a>`);
} else {
// probably not the declaration of x
- P.TaggedString(x.Pos, `<a href="#id` + id + `">`, obj.Ident, `</a>`);
+ P.TaggedString(x.Pos
(), `<a href="#id` + id + `">`, obj.Ident, `</a>`);
}
} else {
- P.String(x.Pos, obj.Ident);
+ P.String(x.Pos(), obj.Ident);
}
}
// ----------------------------------------------------------------------------
// Types
-func (P *Printer) Type(t *AST.Type, full_function_type bool) int
-func (P *Printer) Expr(x *AST.Expr)
-func (P *Printer) Expr1(x *AST.Expr, prec1 int, full_function_type bool)
+func (P *Printer) Type(t *AST.Type) int
+func (P *Printer) Expr(x AST.Expr)
func (P *Printer) Parameters(pos int, list *array.Array) {
P.String(pos, "(");
if list != nil {
var prev int;
for i, n := 0, list.Len(); i < n; i++ {
- x := list.At(i).(*AST.Expr);
+ x := list.At(i).(AST.Expr);
+ tok := Scanner.TYPE;
+ if dummy, is_ident := x.(*AST.Ident); is_ident {
+ tok = Scanner.IDENT;
+ }
if i > 0 {
- if prev == x.Tok || prev == Scanner.TYPE {
+ if prev == tok || prev == Scanner.TYPE {
P.separator = comma;
} else {
P.separator = blank;
}
}
P.Expr(x);
- prev = x.Tok;
+ prev = tok;
}
}
P.String(0, ")");
}
-func (P *Printer) Fields(list *array.Array, end int, full_function_type bool) {
+// Returns the separator (semicolon or none) required if
+// the type is terminating a declaration or statement.
+func (P *Printer) Signature(t *AST.Type) int {
+ assert(t.Form == AST.FUNCTION);
+ separator := none;
+ P.Parameters(t.Pos, t.List);
+ if t.Elt != nil {
+ P.separator = blank;
+ list := t.Elt.List;
+ dummy, is_type := list.At(0).(*AST.TypeLit);
+ if list.Len() > 1 || is_type && dummy.Typ.Form == AST.FUNCTION {
+ // single, anonymous result types which are functions must
+ // be parenthesized as well
+ P.Parameters(0, list);
+ } else {
+ // single, anonymous result type
+ separator = P.Type(list.At(0).(*AST.TypeLit).Typ);
+ }
+ }
+ return separator;
+}
+
+
+func (P *Printer) Fields(list *array.Array, end int, in_interface bool) {
P.state = opening_scope;
P.String(0, "{");
P.newlines = 1;
var prev int;
for i, n := 0, list.Len(); i < n; i++ {
- x := list.At(i).(*AST.Expr);
+ x := list.At(i).(AST.Expr);
+ tok := Scanner.TYPE;
+ if dummy, is_ident := x.(*AST.Ident); is_ident {
+ tok = Scanner.IDENT;
+ } else if dummy, is_lit := x.(*AST.BasicLit); is_lit && dummy.Tok == Scanner.STRING {
+ tok = Scanner.STRING;
+ }
if i > 0 {
- if prev == Scanner.TYPE && x.Tok != Scanner.STRING || prev == Scanner.STRING {
+ if prev == Scanner.TYPE && tok != Scanner.STRING || prev == Scanner.STRING {
P.separator = semicolon;
P.newlines = 1;
- } else if prev == x.Tok {
+ } else if prev == tok {
P.separator = comma;
} else {
P.separator = tab;
}
}
- P.Expr1(x, Scanner.LowestPrec, full_function_type);
- prev = x.Tok;
+ if in_interface && tok == Scanner.TYPE {
+ P.Signature(x.(*AST.TypeLit).Typ);
+ } else {
+ P.Expr(x);
+ }
+ prev = tok;
}
P.newlines = 1;
}
// Returns the separator (semicolon or none) required if
// the type is terminating a declaration or statement.
-func (P *Printer) Type(t *AST.Type, full_function_type bool) int {
+func (P *Printer) Type(t *AST.Type) int {
separator := semicolon;
switch t.Form {
P.Expr(t.Expr);
}
P.String(0, "]");
- separator = P.Type(t.Elt, true);
+ separator = P.Type(t.Elt);
case AST.STRUCT, AST.INTERFACE:
switch t.Form {
}
if t.List != nil {
P.separator = blank;
- P.Fields(t.List, t.End, t.Form == AST.STRUCT);
+ P.Fields(t.List, t.End, t.Form == AST.INTERFACE);
}
separator = none;
case AST.MAP:
P.String(t.Pos, "map [");
- P.Type(t.Key, true);
+ P.Type(t.Key);
P.String(0, "]");
- separator = P.Type(t.Elt, true);
+ separator = P.Type(t.Elt);
case AST.CHANNEL:
var m string;
case AST.SEND: m = "chan <- ";
}
P.String(t.Pos, m);
- separator = P.Type(t.Elt, true);
+ separator = P.Type(t.Elt);
case AST.POINTER:
P.String(t.Pos, "*");
- separator = P.Type(t.Elt, true);
+ separator = P.Type(t.Elt);
case AST.FUNCTION:
- if full_function_type {
- P.Token(0, Scanner.FUNC);
- }
- P.Parameters(t.Pos, t.List);
- if t.Elt != nil {
- P.separator = blank;
- list := t.Elt.List;
- if list.Len() > 1 || list.At(0).(*AST.Expr).Typ.Form == AST.FUNCTION {
- // single, anonymous result types which are functions must
- // be parenthesized as well
- P.Parameters(0, list);
- } else {
- // single, anonymous result type
- P.Expr(list.At(0).(*AST.Expr));
- }
- }
+ P.Token(0, Scanner.FUNC);
+ separator = P.Signature(t);
case AST.ELLIPSIS:
P.String(t.Pos, "...");
// Expressions
func (P *Printer) Block(b *AST.Block, indent bool);
+func (P *Printer) Expr1(x AST.Expr, prec1 int);
-func (P *Printer) Expr1(x *AST.Expr, prec1 int, full_function_type bool) {
- if x == nil {
- return; // empty expression list
- }
- switch x.Tok {
- case Scanner.TYPE:
- // type expr
- P.Type(x.Typ, full_function_type);
+func (P *Printer) DoBadExpr(x *AST.BadExpr) {
+ P.String(0, "BadExpr");
+}
- case Scanner.IDENT:
- P.HtmlIdentifier(x);
- case Scanner.INT, Scanner.STRING, Scanner.FLOAT:
- // literal
- P.String(x.Pos, x.Obj.Ident);
+func (P *Printer) DoIdent(x *AST.Ident) {
+ P.HtmlIdentifier(x);
+}
- case Scanner.FUNC:
- // function literal
- P.String(x.Pos, "func");
- P.Type(x.Obj.Typ, false);
- P.Block(x.Obj.Body, true);
- P.newlines = 0;
- case Scanner.COMMA:
- // list
+func (P *Printer) DoBinaryExpr(x *AST.BinaryExpr) {
+ if x.Tok == Scanner.COMMA {
// (don't use binary expression printing because of different spacing)
P.Expr(x.X);
- P.String(x.Pos, ",");
+ P.String(x.Pos(), ",");
P.separator = blank;
P.state = inside_list;
P.Expr(x.Y);
-
- case Scanner.PERIOD:
- // selector or type guard
- P.Expr1(x.X, Scanner.HighestPrec, true);
- P.String(x.Pos, ".");
- if x.Y.Tok == Scanner.TYPE {
+ } else {
+ prec := Scanner.Precedence(x.Tok);
+ if prec < P.prec {
P.String(0, "(");
- P.Expr(x.Y);
+ }
+ P.Expr1(x.X, prec);
+ P.separator = blank;
+ P.Token(x.Pos(), x.Tok);
+ P.separator = blank;
+ P.Expr1(x.Y, prec);
+ if prec < P.prec {
P.String(0, ")");
- } else {
- P.Expr1(x.Y, Scanner.HighestPrec, true);
}
+ }
+}
- case Scanner.LBRACK:
- // index
- P.Expr1(x.X, Scanner.HighestPrec, true);
- P.String(x.Pos, "[");
- P.Expr1(x.Y, 0, true);
- P.String(0, "]");
- case Scanner.LPAREN:
- // call
- P.Expr1(x.X, Scanner.HighestPrec, true);
- P.String(x.Pos, "(");
- P.Expr(x.Y);
+func (P *Printer) DoUnaryExpr(x *AST.UnaryExpr) {
+ prec := Scanner.UnaryPrec;
+ if prec < P.prec {
+ P.String(0, "(");
+ }
+ P.Token(x.Pos(), x.Tok);
+ if x.Tok == Scanner.RANGE {
+ P.separator = blank;
+ }
+ P.Expr1(x.X, prec);
+ if prec < P.prec {
P.String(0, ")");
+ }
+}
- case Scanner.LBRACE:
- // composite literal
- P.Type(x.Obj.Typ, true);
- P.String(x.Pos, "{");
- P.Expr(x.Y);
- P.String(0, "}");
- default:
- // unary and binary expressions including ":" for pairs
- prec := Scanner.UnaryPrec;
- if x.X != nil {
- prec = Scanner.Precedence(x.Tok);
- }
- if prec < prec1 {
- P.String(0, "(");
- }
- if x.X == nil {
- // unary expression
- P.Token(x.Pos, x.Tok);
- if x.Tok == Scanner.RANGE {
- P.separator = blank;
- }
- } else {
- // binary expression
- P.Expr1(x.X, prec, true);
- P.separator = blank;
- P.Token(x.Pos, x.Tok);
- P.separator = blank;
- }
- P.Expr1(x.Y, prec, true);
- if prec < prec1 {
- P.String(0, ")");
- }
+func (P *Printer) DoBasicLit(x *AST.BasicLit) {
+ P.String(x.Pos(), x.Val);
+}
+
+
+func (P *Printer) DoTypeLit(x *AST.TypeLit) {
+ P.Type(x.Typ);
+}
+
+
+func (P *Printer) DoFunctionLit(x *AST.FunctionLit) {
+ P.String(x.Pos(), "func");
+ P.Signature(x.Typ);
+ P.separator = blank;
+ P.Block(x.Body, true);
+ P.newlines = 0;
+}
+
+
+func (P *Printer) DoCompositeLit(x *AST.CompositeLit) {
+ P.Type(x.Typ);
+ P.String(x.Pos(), "{");
+ P.Expr(x.Elts);
+ P.String(0, "}");
+}
+
+
+func (P *Printer) DoSelector(x *AST.Selector) {
+ P.Expr1(x.X, Scanner.HighestPrec);
+ P.String(x.Pos(), ".");
+ P.Expr1(x.Sel, Scanner.HighestPrec);
+}
+
+
+func (P *Printer) DoTypeGuard(x *AST.TypeGuard) {
+ P.Expr1(x.X, Scanner.HighestPrec);
+ P.String(x.Pos(), ".");
+ P.String(0, "(");
+ P.Type(x.Typ);
+ P.String(0, ")");
+}
+
+
+func (P *Printer) DoIndex(x *AST.Index) {
+ P.Expr1(x.X, Scanner.HighestPrec);
+ P.String(x.Pos(), "[");
+ P.Expr1(x.I, 0);
+ P.String(0, "]");
+}
+
+
+func (P *Printer) DoCall(x *AST.Call) {
+ P.Expr1(x.F, Scanner.HighestPrec);
+ P.String(x.Pos(), "(");
+ P.Expr(x.Args);
+ P.String(0, ")");
+}
+
+
+func (P *Printer) Expr1(x AST.Expr, prec1 int) {
+ if x == nil {
+ return; // empty expression list
}
+
+ saved_prec := P.prec;
+ P.prec = prec1;
+ x.Visit(P);
+ P.prec = saved_prec;
}
-func (P *Printer) Expr(x *AST.Expr) {
- P.Expr1(x, Scanner.LowestPrec, true);
+func (P *Printer) Expr(x AST.Expr) {
+ P.Expr1(x, Scanner.LowestPrec);
}
if d.Ident != nil {
P.Expr(d.Ident);
} else {
- P.String(d.Val.Pos, ""); // flush pending ';' separator/newlines
+ P.String(d.Val.Pos(), ""); // flush pending ';' separator/newlines
}
P.separator = tab;
P.Expr(d.Val);
case Scanner.TYPE:
P.Expr(d.Ident);
P.separator = blank; // TODO switch to tab? (but indentation problem with structs)
- P.separator = P.Type(d.Typ, true);
+ P.separator = P.Type(d.Typ);
case Scanner.CONST, Scanner.VAR:
P.Expr(d.Ident);
if d.Typ != nil {
P.separator = blank; // TODO switch to tab? (indentation problem with structs)
- P.separator = P.Type(d.Typ, true);
+ P.separator = P.Type(d.Typ);
}
if d.Val != nil {
P.separator = tab;
P.separator = blank;
}
P.Expr(d.Ident);
- P.separator = P.Type(d.Typ, false);
- if d.Val != nil {
+ P.separator = P.Signature(d.Typ);
+ if d.Body != nil {
P.separator = blank;
- P.Block(d.Val.Obj.Body, true);
+ P.Block(d.Body, true);
}
default:
P.Init(text, prog.Comments);
// TODO would be better to make the name of the src file be the title
- P.HtmlPrologue("package " + prog.Ident.Obj.Ident);
+ P.HtmlPrologue("package " + prog.Ident.(*AST.Ident).Obj.Ident);
P.Program(prog);
P.HtmlEpilogue();