import (
"vector";
"token";
+ "scanner";
)
}
-// ----------------------------------------------------------------------------
-// All nodes have a source position and a token.
-
-type Node struct {
- Pos int; // source position (< 0 => unknown position)
- Tok int; // identifying token
-}
-
-
// ----------------------------------------------------------------------------
// Expressions
Signature struct;
Expr interface {
- Pos() int;
+ Loc() scanner.Location;
Visit(v ExprVisitor);
};
BadExpr struct {
- Pos_ int;
+ Loc_ scanner.Location;
};
Ident struct {
- Pos_ int;
+ Loc_ scanner.Location;
Str string;
};
BinaryExpr struct {
- Pos_ int;
+ Loc_ scanner.Location;
Tok int;
X, Y Expr;
};
UnaryExpr struct {
- Pos_ int;
+ Loc_ scanner.Location;
Tok int;
X Expr;
};
};
BasicLit struct {
- Pos_ int;
+ Loc_ scanner.Location;
Tok int;
Val []byte;
};
FunctionLit struct {
- Pos_ int; // position of "func"
+ Loc_ scanner.Location; // location of "func"
Typ *Signature;
Body *Block;
};
Group struct {
- Pos_ int; // position of "("
+ Loc_ scanner.Location; // location of "("
X Expr;
};
Selector struct {
- Pos_ int; // position of "."
+ Loc_ scanner.Location; // location of "."
X Expr;
Sel *Ident;
};
TypeGuard struct {
- Pos_ int; // position of "."
+ Loc_ scanner.Location; // location of "."
X Expr;
Typ Expr;
};
Index struct {
- Pos_ int; // position of "["
+ Loc_ scanner.Location; // location of "["
X, I Expr;
};
Call struct {
- Pos_ int; // position of "(" or "{"
+ Loc_ scanner.Location; // location of "(" or "{"
Tok int;
F, Args Expr
};
// Type literals are treated like expressions.
Ellipsis struct { // neither a type nor an expression
- Pos_ int;
+ Loc_ scanner.Location;
};
TypeType struct { // for type switches
- Pos_ int; // position of "type"
+ Loc_ scanner.Location; // location of "type"
};
ArrayType struct {
- Pos_ int; // position of "["
+ Loc_ scanner.Location; // location of "["
Len Expr;
Elt Expr;
};
};
StructType struct {
- Pos_ int; // position of "struct"
+ Loc_ scanner.Location; // location of "struct"
Fields []*Field;
- End int; // position of "}", End == 0 if forward declaration
+ End scanner.Location; // location of "}"
};
PointerType struct {
- Pos_ int; // position of "*"
+ Loc_ scanner.Location; // location of "*"
Base Expr;
};
};
FunctionType struct {
- Pos_ int; // position of "func"
+ Loc_ scanner.Location; // location of "func"
Sig *Signature;
};
InterfaceType struct {
- Pos_ int; // position of "interface"
+ Loc_ scanner.Location; // location of "interface"
Methods []*Field;
- End int; // position of "}", End == 0 if forward declaration
+ End scanner.Location; // location of "}", End == 0 if forward declaration
};
SliceType struct {
- Pos_ int; // position of "["
+ Loc_ scanner.Location; // location of "["
};
MapType struct {
- Pos_ int; // position of "map"
+ Loc_ scanner.Location; // location of "map"
Key Expr;
Val Expr;
};
ChannelType struct {
- Pos_ int; // position of "chan" or "<-"
+ Loc_ scanner.Location; // location of "chan" or "<-"
Mode int;
Val Expr;
};
// TODO replace these with an embedded field
-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 *ConcatExpr) Pos() int { return x.X.Pos(); }
-func (x *BasicLit) Pos() int { return x.Pos_; }
-func (x *FunctionLit) Pos() int { return x.Pos_; }
-func (x *Group) Pos() int { return x.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 *Ellipsis) Pos() int { return x.Pos_; }
-func (x *TypeType) Pos() int { return x.Pos_; }
-func (x *ArrayType) Pos() int { return x.Pos_; }
-func (x *StructType) Pos() int { return x.Pos_; }
-func (x *PointerType) Pos() int { return x.Pos_; }
-func (x *FunctionType) Pos() int { return x.Pos_; }
-func (x *InterfaceType) Pos() int { return x.Pos_; }
-func (x *SliceType) Pos() int { return x.Pos_; }
-func (x *MapType) Pos() int { return x.Pos_; }
-func (x *ChannelType) Pos() int { return x.Pos_; }
+func (x *BadExpr) Loc() scanner.Location { return x.Loc_; }
+func (x *Ident) Loc() scanner.Location { return x.Loc_; }
+func (x *BinaryExpr) Loc() scanner.Location { return x.Loc_; }
+func (x *UnaryExpr) Loc() scanner.Location { return x.Loc_; }
+func (x *ConcatExpr) Loc() scanner.Location { return x.X.Loc(); }
+func (x *BasicLit) Loc() scanner.Location { return x.Loc_; }
+func (x *FunctionLit) Loc() scanner.Location { return x.Loc_; }
+func (x *Group) Loc() scanner.Location { return x.Loc_; }
+func (x *Selector) Loc() scanner.Location { return x.Loc_; }
+func (x *TypeGuard) Loc() scanner.Location { return x.Loc_; }
+func (x *Index) Loc() scanner.Location { return x.Loc_; }
+func (x *Call) Loc() scanner.Location { return x.Loc_; }
+
+func (x *Ellipsis) Loc() scanner.Location { return x.Loc_; }
+func (x *TypeType) Loc() scanner.Location { return x.Loc_; }
+func (x *ArrayType) Loc() scanner.Location { return x.Loc_; }
+func (x *StructType) Loc() scanner.Location { return x.Loc_; }
+func (x *PointerType) Loc() scanner.Location { return x.Loc_; }
+func (x *FunctionType) Loc() scanner.Location { return x.Loc_; }
+func (x *InterfaceType) Loc() scanner.Location { return x.Loc_; }
+func (x *SliceType) Loc() scanner.Location { return x.Loc_; }
+func (x *MapType) Loc() scanner.Location { return x.Loc_; }
+func (x *ChannelType) Loc() scanner.Location { return x.Loc_; }
func (x *BadExpr) Visit(v ExprVisitor) { v.DoBadExpr(x); }
// ":" StatementList
type Block struct {
- Node;
+ Loc scanner.Location;
+ Tok int;
List *vector.Vector;
- End int; // position of closing "}" if present
+ End scanner.Location; // location of closing "}" if present
}
-func NewBlock(pos, tok int) *Block {
+func NewBlock(loc scanner.Location, tok int) *Block {
assert(tok == token.LBRACE || tok == token.COLON);
- b := new(Block);
- b.Pos, b.Tok, b.List = pos, tok, vector.New(0);
- return b;
+ var end scanner.Location;
+ return &Block{loc, tok, vector.New(0), end};
}
};
BadStat struct {
- Pos int;
+ Loc scanner.Location;
};
LabelDecl struct {
- Pos int; // position of ":"
+ Loc scanner.Location; // location of ":"
Label *Ident;
};
};
ExpressionStat struct {
- Pos int; // position of Tok
+ Loc scanner.Location; // location of Tok
Tok int; // INC, DEC, RETURN, GO, DEFER
Expr Expr;
};
};
IfStat struct {
- Pos int; // position of "if"
+ Loc scanner.Location; // location of "if"
Init Stat;
Cond Expr;
Body *Block;
};
ForStat struct {
- Pos int; // position of "for"
+ Loc scanner.Location; // location of "for"
Init Stat;
Cond Expr;
Post Stat;
};
CaseClause struct {
- Pos int; // position for "case" or "default"
+ Loc scanner.Location; // position for "case" or "default"
Expr Expr; // nil means default case
Body *Block;
};
SwitchStat struct {
- Pos int; // position of "switch"
+ Loc scanner.Location; // location of "switch"
Init Stat;
Tag Expr;
Body *Block;
};
SelectStat struct {
- Pos int; // position of "select"
+ Loc scanner.Location; // location of "select"
Body *Block;
};
ControlFlowStat struct {
- Pos int; // position of Tok
+ Loc scanner.Location; // location of Tok
Tok int; // BREAK, CONTINUE, GOTO, FALLTHROUGH
Label *Ident; // if any, or nil
};
EmptyStat struct {
- Pos int; // position of ";"
+ Loc scanner.Location; // location of ";"
};
)
};
BadDecl struct {
- Pos int;
+ Loc scanner.Location;
};
ImportDecl struct {
- Pos int; // if > 0: position of "import"
+ Loc scanner.Location; // if > 0: position of "import"
Ident *Ident;
Path Expr;
};
ConstDecl struct {
- Pos int; // if > 0: position of "const"
+ Loc scanner.Location; // if > 0: position of "const"
Idents []*Ident;
Typ Expr;
Vals Expr;
};
TypeDecl struct {
- Pos int; // if > 0: position of "type"
+ Loc scanner.Location; // if > 0: position of "type"
Ident *Ident;
Typ Expr;
};
VarDecl struct {
- Pos int; // if > 0: position of "var"
+ Loc scanner.Location; // if > 0: position of "var"
Idents []*Ident;
Typ Expr;
Vals Expr;
};
FuncDecl struct {
- Pos int; // position of "func"
+ Loc scanner.Location; // location of "func"
Recv *Field;
Ident *Ident;
Sig *Signature;
};
DeclList struct {
- Pos int; // position of Tok
+ Loc scanner.Location; // location of Tok
Tok int;
List []Decl;
- End int;
+ End scanner.Location;
};
)
// Program
type Comment struct {
- Pos int;
+ Loc scanner.Location;
Text []byte;
}
type Program struct {
- Pos int; // tok is token.PACKAGE
+ Loc scanner.Location; // tok is token.PACKAGE
Ident *Ident;
Decls []Decl;
Comments []*Comment;
}
-func NewProgram(pos int) *Program {
+func NewProgram(loc scanner.Location) *Program {
p := new(Program);
- p.Pos = pos;
+ p.Loc = loc;
return p;
}
"os";
Utils "utils";
Platform "platform";
- Scanner "scanner";
+ "scanner";
Parser "parser";
AST "ast";
TypeChecker "typechecker";
type errorHandler struct {
filename string;
src []byte;
- nerrors int;
- nwarnings int;
- errpos int;
columns bool;
+ errline int;
+ nerrors int;
}
func (h *errorHandler) Init(filename string, src []byte, columns bool) {
h.filename = filename;
h.src = src;
- h.nerrors = 0;
- h.nwarnings = 0;
- h.errpos = 0;
h.columns = columns;
}
+/*
// Compute (line, column) information for a given source position.
func (h *errorHandler) LineCol(pos int) (line, col int) {
line = 1;
return line, utf8.RuneCount(src[lpos : pos]);
}
+*/
-func (h *errorHandler) ErrorMsg(pos int, msg string) {
- print(h.filename, ":");
- if pos >= 0 {
- // print position
- line, col := h.LineCol(pos);
- print(line, ":");
- if h.columns {
- print(col, ":");
- }
+func (h *errorHandler) ErrorMsg(loc scanner.Location, msg string) {
+ fmt.Printf("%s:%d:", h.filename, loc.Line);
+ if h.columns {
+ fmt.Printf("%d:", loc.Col);
}
- print(" ", msg, "\n");
+ fmt.Printf(" %s\n", msg);
- h.nerrors++;
- h.errpos = pos;
+ h.errline = loc.Line;
+ h.nerrors++;
if h.nerrors >= 10 {
sys.Exit(1);
}
}
-func (h *errorHandler) Error(pos int, msg string) {
- // only report errors that are sufficiently far away from the previous error
+func (h *errorHandler) Error(loc scanner.Location, msg string) {
+ // only report errors that are on a new line
// in the hope to avoid most follow-up errors
- const errdist = 20;
- delta := pos - h.errpos; // may be negative!
- if delta < 0 {
- delta = -delta;
- }
-
- if delta > errdist || h.nerrors == 0 /* always report first error */ {
- h.ErrorMsg(pos, msg);
+ if loc.Line != h.errline {
+ h.ErrorMsg(loc, msg);
}
}
var err errorHandler;
err.Init(src_file, src, flags.Columns);
- var scanner Scanner.Scanner;
+ var scanner scanner.Scanner;
scanner.Init(src, &err, true);
var parser Parser.Parser;
decl := prog.Decls[i];
panic();
/*
- assert(decl.Tok == Scanner.IMPORT);
+ assert(decl.Tok == scanner.IMPORT);
if decl.List == nil {
printDep(localset, wset, decl);
} else {
"fmt";
"vector";
"token";
+ "scanner";
"ast";
)
-// An implementation of an ErrorHandler must be provided to the Parser.
-// If a syntax error is encountered, Error is called with the exact
-// token position (the byte position of the token in the source) and the
-// error message.
-//
-type ErrorHandler interface {
- Error(pos int, msg string);
-}
-
-
-// An implementation of a Scanner must be provided to the Parser.
-// The parser calls Scan repeatedly to get a sequential stream of
-// tokens. The source end is indicated by token.EOF.
-//
-type Scanner interface {
- Scan() (pos, tok int, lit []byte);
-}
-
-
// A Parser holds the parser's internal state while processing
// a given text. It can be allocated as part of another data
// structure but must be initialized via Init before use.
//
type Parser struct {
- scanner Scanner;
- err ErrorHandler;
+ scanner *scanner.Scanner;
+ err scanner.ErrorHandler;
// Tracing/debugging
trace bool;
comments *vector.Vector;
// The next token
- pos int; // token source position
+ loc scanner.Location; // token location
tok int; // one token look-ahead
val []byte; // token value
};
+// When we don't have a location use noloc.
+// TODO make sure we always have a location.
+var noloc scanner.Location;
+
+
// ----------------------------------------------------------------------------
// Helper functions
func (P *Parser) next0() {
- var val []byte;
- P.pos, P.tok, P.val = P.scanner.Scan();
+ P.loc, P.tok, P.val = P.scanner.Scan();
P.opt_semi = false;
if P.trace {
P.printIndent();
switch P.tok {
case token.IDENT, token.INT, token.FLOAT, token.CHAR, token.STRING:
- fmt.Printf("[%d] %s = %s\n", P.pos, token.TokenString(P.tok), P.val);
+ fmt.Printf("%d:%d: %s = %s\n", P.loc.Line, P.loc.Col, token.TokenString(P.tok), P.val);
case token.LPAREN:
// don't print '(' - screws up selection in terminal window
- fmt.Printf("[%d] LPAREN\n", P.pos);
+ fmt.Printf("%d:%d: LPAREN\n", P.loc.Line, P.loc.Col);
case token.RPAREN:
// don't print ')' - screws up selection in terminal window
- fmt.Printf("[%d] RPAREN\n", P.pos);
+ fmt.Printf("%d:%d: RPAREN\n", P.loc.Line, P.loc.Col);
default:
- fmt.Printf("[%d] %s\n", P.pos, token.TokenString(P.tok));
+ fmt.Printf("%d:%d: %s\n", P.loc.Line, P.loc.Col, token.TokenString(P.tok));
}
}
}
func (P *Parser) next() {
for P.next0(); P.tok == token.COMMENT; P.next0() {
- P.comments.Push(&ast.Comment{P.pos, P.val});
+ P.comments.Push(&ast.Comment{P.loc, P.val});
}
}
-func (P *Parser) Init(scanner Scanner, err ErrorHandler, trace bool) {
+func (P *Parser) Init(scanner *scanner.Scanner, err scanner.ErrorHandler, trace bool) {
P.scanner = scanner;
P.err = err;
}
-func (P *Parser) error(pos int, msg string) {
- P.err.Error(pos, msg);
+func (P *Parser) error(loc scanner.Location, msg string) {
+ P.err.Error(loc, msg);
}
if token.IsLiteral(P.tok) {
msg += " " + string(P.val);
}
- P.error(P.pos, msg);
+ P.error(P.loc, msg);
}
P.next(); // make progress in any case
}
}
if P.tok == token.IDENT {
- x := &ast.Ident{P.pos, string(P.val)};
+ x := &ast.Ident{P.loc, string(P.val)};
P.next();
return x;
}
P.expect(token.IDENT); // use expect() error handling
- return &ast.Ident{P.pos, ""};
+ return &ast.Ident{P.loc, ""};
}
x = P.parseIdent();
}
for P.tok == token.COMMA {
- pos := P.pos;
+ loc := P.loc;
P.next();
y := P.parseIdent();
if last == nil {
- last = &ast.BinaryExpr{pos, token.COMMA, x, y};
+ last = &ast.BinaryExpr{loc, token.COMMA, x, y};
x = last;
} else {
- last.Y = &ast.BinaryExpr{pos, token.COMMA, last.Y, y};
+ last.Y = &ast.BinaryExpr{loc, token.COMMA, last.Y, y};
last = last.Y.(*ast.BinaryExpr);
}
}
t := P.tryType();
if t == nil {
- P.error(P.pos, "type expected");
- t = &ast.BadExpr{P.pos};
+ P.error(P.loc, "type expected");
+ t = &ast.BadExpr{P.loc};
}
return t;
var x ast.Expr = P.parseIdent();
for P.tok == token.PERIOD {
- pos := P.pos;
+ loc := P.loc;
P.next();
y := P.parseIdent();
- x = &ast.Selector{pos, x, y};
+ x = &ast.Selector{loc, x, y};
}
return x;
defer un(trace(P, "ArrayType"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.LBRACK);
var len ast.Expr;
if P.tok == token.ELLIPSIS {
- len = &ast.Ellipsis{P.pos};
+ len = &ast.Ellipsis{P.loc};
P.next();
} else if P.tok != token.RBRACK {
len = P.parseExpression(1);
P.expect(token.RBRACK);
elt := P.parseType();
- return &ast.ArrayType{pos, len, elt};
+ return &ast.ArrayType{loc, len, elt};
}
defer un(trace(P, "ChannelType"));
}
- pos := P.pos;
+ loc := P.loc;
mode := ast.FULL;
if P.tok == token.CHAN {
P.next();
}
val := P.parseVarType();
- return &ast.ChannelType{pos, mode, val};
+ return &ast.ChannelType{loc, mode, val};
}
func (P *Parser) tryParameterType() ast.Expr {
if P.tok == token.ELLIPSIS {
- pos := P.tok;
+ loc := P.loc;
P.next();
- return &ast.Ellipsis{pos};
+ return &ast.Ellipsis{loc};
}
return P.tryType();
}
func (P *Parser) parseParameterType() ast.Expr {
typ := P.tryParameterType();
if typ == nil {
- P.error(P.tok, "type expected");
- typ = &ast.BadExpr{P.pos};
+ P.error(P.loc, "type expected");
+ typ = &ast.BadExpr{P.loc};
}
return typ;
}
}
params := P.parseParameters(true); // TODO find better solution
- //t.End = P.pos;
+ //t.End = P.loc;
result := P.parseResult();
return &ast.Signature{params, result};
defer un(trace(P, "FunctionType"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.FUNC);
sig := P.parseSignature();
- return &ast.FunctionType{pos, sig};
+ return &ast.FunctionType{loc, sig};
}
if tmp, is_ident := x.(*ast.Ident); is_ident && (P.tok == token.COMMA || P.tok == token.LPAREN) {
// method(s)
idents = P.parseIdentList2(x);
- typ = &ast.FunctionType{0, P.parseSignature()};
+ typ = &ast.FunctionType{noloc, P.parseSignature()};
} else {
// embedded interface
typ = x;
defer un(trace(P, "InterfaceType"));
}
- pos := P.pos;
- end := 0;
+ loc := P.loc;
+ var end scanner.Location;
var methods []*ast.Field;
P.expect(token.INTERFACE);
}
}
- end = P.pos;
+ end = P.loc;
P.expect(token.RBRACE);
P.opt_semi = true;
}
}
- return &ast.InterfaceType{pos, methods, end};
+ return &ast.InterfaceType{loc, methods, end};
}
defer un(trace(P, "MapType"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.MAP);
P.expect(token.LBRACK);
key := P.parseVarType();
P.expect(token.RBRACK);
val := P.parseVarType();
- return &ast.MapType{pos, key, val};
+ return &ast.MapType{loc, key, val};
}
if ident, is_ident := list.At(i).(*ast.Ident); is_ident {
idents[i] = ident;
} else {
- P.error(list.At(i).(ast.Expr).Pos(), "identifier expected");
+ P.error(list.At(i).(ast.Expr).Loc(), "identifier expected");
}
}
} else {
// TODO should do more checks here
typ = list.At(0).(ast.Expr);
} else {
- P.error(P.pos, "anonymous field expected");
+ P.error(P.loc, "anonymous field expected");
}
}
defer un(trace(P, "StructType"));
}
- pos := P.pos;
- end := 0;
+ loc := P.loc;
+ var end scanner.Location;
var fields []*ast.Field;
P.expect(token.STRUCT);
P.next();
}
- end = P.pos;
+ end = P.loc;
P.expect(token.RBRACE);
P.opt_semi = true;
}
}
- return ast.StructType{pos, fields, end};
+ return ast.StructType{loc, fields, end};
}
defer un(trace(P, "PointerType"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.MUL);
base := P.parseType();
- return &ast.PointerType{pos, base};
+ return &ast.PointerType{loc, base};
}
case token.STRUCT: return P.parseStructType();
case token.MUL: return P.parsePointerType();
case token.LPAREN:
- pos := P.pos;
+ loc := P.loc;
P.next();
t := P.parseType();
P.expect(token.RPAREN);
- return &ast.Group{pos, t};
+ return &ast.Group{loc, t};
}
// no type found
defer un(trace(P, "Block"));
}
- b := ast.NewBlock(P.pos, tok);
+ b := ast.NewBlock(P.loc, tok);
P.expect(tok);
P.parseStatementList(b.List);
if tok == token.LBRACE {
- b.End = P.pos;
+ b.End = P.loc;
P.expect(token.RBRACE);
P.opt_semi = true;
}
x := P.parseExpression(1);
for first := true; P.tok == token.COMMA; {
- pos := P.pos;
+ loc := P.loc;
P.next();
y := P.parseExpression(1);
if first {
- x = &ast.BinaryExpr{pos, token.COMMA, x, y};
+ x = &ast.BinaryExpr{loc, token.COMMA, x, y};
first = false;
} else {
- x.(*ast.BinaryExpr).Y = &ast.BinaryExpr{pos, token.COMMA, x.(*ast.BinaryExpr).Y, y};
+ x.(*ast.BinaryExpr).Y = &ast.BinaryExpr{loc, token.COMMA, x.(*ast.BinaryExpr).Y, y};
}
}
defer un(trace(P, "FunctionLit"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.FUNC);
typ := P.parseSignature();
P.expr_lev++;
body := P.parseBlock(token.LBRACE);
P.expr_lev--;
- return &ast.FunctionLit{pos, typ, body};
+ return &ast.FunctionLit{loc, typ, body};
}
defer un(trace(P, "StringLit"));
}
- var x ast.Expr = &ast.BasicLit{P.pos, P.tok, P.val};
+ var x ast.Expr = &ast.BasicLit{P.loc, P.tok, P.val};
P.expect(token.STRING); // always satisfied
for P.tok == token.STRING {
- y := &ast.BasicLit{P.pos, P.tok, P.val};
+ y := &ast.BasicLit{P.loc, P.tok, P.val};
P.next();
x = &ast.ConcatExpr{x, y};
}
return P.parseIdent();
case token.INT, token.FLOAT, token.CHAR:
- x := &ast.BasicLit{P.pos, P.tok, P.val};
+ x := &ast.BasicLit{P.loc, P.tok, P.val};
P.next();
return x;
return P.parseStringLit();
case token.LPAREN:
- pos := P.pos;
+ loc := P.loc;
P.next();
P.expr_lev++;
x := P.parseExpression(1);
P.expr_lev--;
P.expect(token.RPAREN);
- return &ast.Group{pos, x};
+ return &ast.Group{loc, x};
case token.FUNC:
return P.parseFunctionLit();
if t != nil {
return t;
} else {
- P.error(P.pos, "operand expected");
+ P.error(P.loc, "operand expected");
P.next(); // make progress
}
}
- return &ast.BadExpr{P.pos};
+ return &ast.BadExpr{P.loc};
}
defer un(trace(P, "SelectorOrTypeGuard"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.PERIOD);
if P.tok == token.IDENT {
- x = &ast.Selector{pos, x, P.parseIdent()};
+ x = &ast.Selector{loc, x, P.parseIdent()};
} else {
P.expect(token.LPAREN);
var typ ast.Expr;
if P.tok == token.TYPE {
- typ = &ast.TypeType{P.pos};
+ typ = &ast.TypeType{P.loc};
P.next();
} else {
typ = P.parseType();
}
- x = &ast.TypeGuard{pos, x, typ};
+ x = &ast.TypeGuard{loc, x, typ};
P.expect(token.RPAREN);
}
defer un(trace(P, "IndexOrSlice"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.LBRACK);
P.expr_lev++;
i := P.parseExpression(0);
P.expr_lev--;
P.expect(token.RBRACK);
- return &ast.Index{pos, x, i};
+ return &ast.Index{loc, x, i};
}
func (P *Parser) parseCompositeElements(close int) ast.Expr {
x := P.parseExpression(0);
if P.tok == token.COMMA {
- pos := P.pos;
+ loc := P.loc;
P.next();
// first element determines mode
if singles {
if t, is_binary := y.(*ast.BinaryExpr); is_binary && t.Tok == token.COLON {
- P.error(t.X.Pos(), "single value expected; found pair");
+ P.error(t.X.Loc(), "single value expected; found pair");
}
} else {
if t, is_binary := y.(*ast.BinaryExpr); !is_binary || t.Tok != token.COLON {
- P.error(y.Pos(), "key:value pair expected; found single value");
+ P.error(y.Loc(), "key:value pair expected; found single value");
}
}
if last == nil {
- last = &ast.BinaryExpr{pos, token.COMMA, x, y};
+ last = &ast.BinaryExpr{loc, token.COMMA, x, y};
x = last;
} else {
- last.Y = &ast.BinaryExpr{pos, token.COMMA, last.Y, y};
+ last.Y = &ast.BinaryExpr{loc, token.COMMA, last.Y, y};
last = last.Y.(*ast.BinaryExpr);
}
if P.tok == token.COMMA {
- pos = P.pos;
+ loc = P.loc;
P.next();
} else {
break;
defer un(trace(P, "CallOrCompositeLit"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(open);
var args ast.Expr;
if P.tok != close {
}
P.expect(close);
- return &ast.Call{pos, open, f, args};
+ return &ast.Call{loc, open, f, args};
}
switch P.tok {
case token.ADD, token.SUB, token.MUL, token.NOT, token.XOR, token.ARROW, token.AND:
- pos, tok := P.pos, P.tok;
+ loc, tok := P.loc, P.tok;
P.next();
y := P.parseUnaryExpr();
- return &ast.UnaryExpr{pos, tok, y};
+ return &ast.UnaryExpr{loc, tok, y};
/*
if lit, ok := y.(*ast.TypeLit); ok && tok == token.MUL {
// pointer type
t.Elt = lit.Typ;
return &ast.TypeLit{t};
} else {
- return &ast.UnaryExpr{pos, tok, y};
+ return &ast.UnaryExpr{loc, tok, y};
}
*/
}
x := P.parseUnaryExpr();
for prec := token.Precedence(P.tok); prec >= prec1; prec-- {
for token.Precedence(P.tok) == prec {
- pos, tok := P.pos, P.tok;
+ loc, tok := P.loc, P.tok;
P.next();
y := P.parseBinaryExpr(prec + 1);
- x = &ast.BinaryExpr{pos, tok, x, y};
+ x = &ast.BinaryExpr{loc, tok, x, y};
}
}
switch P.tok {
case token.COLON:
// label declaration
- pos := P.pos;
+ loc := P.loc;
P.next(); // consume ":"
P.opt_semi = true;
if ast.ExprLen(x) == 1 {
if label, is_ident := x.(*ast.Ident); is_ident {
- return &ast.LabelDecl{pos, label};
+ return &ast.LabelDecl{loc, label};
}
}
- P.error(x.Pos(), "illegal label declaration");
+ P.error(x.Loc(), "illegal label declaration");
return nil;
case
token.REM_ASSIGN, token.AND_ASSIGN, token.OR_ASSIGN,
token.XOR_ASSIGN, token.SHL_ASSIGN, token.SHR_ASSIGN:
// declaration/assignment
- pos, tok := P.pos, P.tok;
+ loc, tok := P.loc, P.tok;
P.next();
var y ast.Expr;
if range_ok && P.tok == token.RANGE {
- range_pos := P.pos;
+ range_loc := P.loc;
P.next();
- y = &ast.UnaryExpr{range_pos, token.RANGE, P.parseExpression(1)};
+ y = &ast.UnaryExpr{range_loc, token.RANGE, P.parseExpression(1)};
if tok != token.DEFINE && tok != token.ASSIGN {
- P.error(pos, "expected '=' or ':=', found '" + token.TokenString(tok) + "'");
+ P.error(loc, "expected '=' or ':=', found '" + token.TokenString(tok) + "'");
}
} else {
y = P.parseExpressionList();
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");
+ P.error(x.Loc(), "arity of lhs doesn't match rhs");
}
}
// TODO changed ILLEGAL -> NONE
- return &ast.ExpressionStat{x.Pos(), token.ILLEGAL, &ast.BinaryExpr{pos, tok, x, y}};
+ return &ast.ExpressionStat{x.Loc(), token.ILLEGAL, &ast.BinaryExpr{loc, tok, x, y}};
default:
if ast.ExprLen(x) != 1 {
- P.error(x.Pos(), "only one expression allowed");
+ P.error(x.Loc(), "only one expression allowed");
}
if P.tok == token.INC || P.tok == token.DEC {
- s := &ast.ExpressionStat{P.pos, P.tok, x};
+ s := &ast.ExpressionStat{P.loc, P.tok, x};
P.next(); // consume "++" or "--"
return s;
}
// TODO changed ILLEGAL -> NONE
- return &ast.ExpressionStat{x.Pos(), token.ILLEGAL, x};
+ return &ast.ExpressionStat{x.Loc(), token.ILLEGAL, x};
}
unreachable();
defer un(trace(P, "InvocationStat"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(keyword);
- return &ast.ExpressionStat{pos, keyword, P.parseExpression(1)};
+ return &ast.ExpressionStat{loc, keyword, P.parseExpression(1)};
}
defer un(trace(P, "ReturnStat"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.RETURN);
var x ast.Expr;
if P.tok != token.SEMICOLON && P.tok != token.RBRACE {
x = P.parseExpressionList();
}
- return &ast.ExpressionStat{pos, token.RETURN, x};
+ return &ast.ExpressionStat{loc, token.RETURN, x};
}
defer un(trace(P, "ControlFlowStat"));
}
- s := &ast.ControlFlowStat{P.pos, tok, nil};
+ s := &ast.ControlFlowStat{P.loc, tok, nil};
P.expect(tok);
if tok != token.FALLTHROUGH && P.tok == token.IDENT {
s.Label = P.parseIdent();
if s, is_expr_stat := init.(*ast.ExpressionStat); is_expr_stat {
expr, init = s.Expr, nil;
} else {
- P.error(0, "illegal control clause");
+ P.error(noloc, "illegal control clause");
}
}
}
defer un(trace(P, "IfStat"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.IF);
init, cond, dummy := P.parseControlClause(false);
body := P.parseBlock(token.LBRACE);
else_ = P.parseStatement();
}
- return &ast.IfStat{pos, init, cond, body, else_};
+ return &ast.IfStat{loc, init, cond, body, else_};
}
defer un(trace(P, "ForStat"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.FOR);
init, cond, post := P.parseControlClause(true);
body := P.parseBlock(token.LBRACE);
- return &ast.ForStat{pos, init, cond, post, body};
+ return &ast.ForStat{loc, init, cond, post, body};
}
}
// SwitchCase
- pos := P.pos;
+ loc := P.loc;
var expr ast.Expr;
if P.tok == token.CASE {
P.next();
P.expect(token.DEFAULT);
}
- return &ast.CaseClause{pos, expr, P.parseBlock(token.COLON)};
+ return &ast.CaseClause{loc, expr, P.parseBlock(token.COLON)};
}
defer un(trace(P, "SwitchStat"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.SWITCH);
init, tag, post := P.parseControlClause(false);
- body := ast.NewBlock(P.pos, token.LBRACE);
+ body := ast.NewBlock(P.loc, token.LBRACE);
P.expect(token.LBRACE);
for P.tok != token.RBRACE && P.tok != token.EOF {
body.List.Push(P.parseCaseClause());
}
- body.End = P.pos;
+ body.End = P.loc;
P.expect(token.RBRACE);
P.opt_semi = true;
- return &ast.SwitchStat{pos, init, tag, body};
+ return &ast.SwitchStat{loc, init, tag, body};
}
}
// CommCase
- pos := P.pos;
+ loc := P.loc;
var expr ast.Expr;
if P.tok == token.CASE {
P.next();
x := P.parseExpression(1);
if P.tok == token.ASSIGN || P.tok == token.DEFINE {
- pos, tok := P.pos, P.tok;
+ loc, tok := P.loc, P.tok;
P.next();
if P.tok == token.ARROW {
y := P.parseExpression(1);
- x = &ast.BinaryExpr{pos, tok, x, y};
+ x = &ast.BinaryExpr{loc, tok, x, y};
} else {
P.expect(token.ARROW); // use expect() error handling
}
P.expect(token.DEFAULT);
}
- return &ast.CaseClause{pos, expr, P.parseBlock(token.COLON)};
+ return &ast.CaseClause{loc, expr, P.parseBlock(token.COLON)};
}
defer un(trace(P, "SelectStat"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.SELECT);
- body := ast.NewBlock(P.pos, token.LBRACE);
+ body := ast.NewBlock(P.loc, token.LBRACE);
P.expect(token.LBRACE);
for P.tok != token.RBRACE && P.tok != token.EOF {
body.List.Push(P.parseCommClause());
}
- body.End = P.pos;
+ body.End = P.loc;
P.expect(token.RBRACE);
P.opt_semi = true;
- return &ast.SelectStat{pos, body};
+ return &ast.SelectStat{loc, body};
}
return P.parseSelectStat();
case token.SEMICOLON:
// don't consume the ";", it is the separator following the empty statement
- return &ast.EmptyStat{P.pos};
+ return &ast.EmptyStat{P.loc};
}
// no statement found
- P.error(P.pos, "statement expected");
- return &ast.BadStat{P.pos};
+ P.error(P.loc, "statement expected");
+ return &ast.BadStat{P.loc};
}
// ----------------------------------------------------------------------------
// Declarations
-func (P *Parser) parseImportSpec(pos int) *ast.ImportDecl {
+func (P *Parser) parseImportSpec(loc scanner.Location) *ast.ImportDecl {
if P.trace {
defer un(trace(P, "ImportSpec"));
}
var ident *ast.Ident;
if P.tok == token.PERIOD {
- P.error(P.pos, `"import ." not yet handled properly`);
+ P.error(P.loc, `"import ." not yet handled properly`);
P.next();
} else if P.tok == token.IDENT {
ident = P.parseIdent();
P.expect(token.STRING); // use expect() error handling
}
- return &ast.ImportDecl{pos, ident, path};
+ return &ast.ImportDecl{loc, ident, path};
}
-func (P *Parser) parseConstSpec(pos int) *ast.ConstDecl {
+func (P *Parser) parseConstSpec(loc scanner.Location) *ast.ConstDecl {
if P.trace {
defer un(trace(P, "ConstSpec"));
}
vals = P.parseExpressionList();
}
- return &ast.ConstDecl{pos, idents, typ, vals};
+ return &ast.ConstDecl{loc, idents, typ, vals};
}
-func (P *Parser) parseTypeSpec(pos int) *ast.TypeDecl {
+func (P *Parser) parseTypeSpec(loc scanner.Location) *ast.TypeDecl {
if P.trace {
defer un(trace(P, "TypeSpec"));
}
ident := P.parseIdent();
typ := P.parseType();
- return &ast.TypeDecl{pos, ident, typ};
+ return &ast.TypeDecl{loc, ident, typ};
}
-func (P *Parser) parseVarSpec(pos int) *ast.VarDecl {
+func (P *Parser) parseVarSpec(loc scanner.Location) *ast.VarDecl {
if P.trace {
defer un(trace(P, "VarSpec"));
}
}
}
- return &ast.VarDecl{pos, idents, typ, vals};
+ return &ast.VarDecl{loc, idents, typ, vals};
}
-func (P *Parser) parseSpec(pos, keyword int) ast.Decl {
+func (P *Parser) parseSpec(loc scanner.Location, keyword int) ast.Decl {
switch keyword {
- case token.IMPORT: return P.parseImportSpec(pos);
- case token.CONST: return P.parseConstSpec(pos);
- case token.TYPE: return P.parseTypeSpec(pos);
- case token.VAR: return P.parseVarSpec(pos);
+ case token.IMPORT: return P.parseImportSpec(loc);
+ case token.CONST: return P.parseConstSpec(loc);
+ case token.TYPE: return P.parseTypeSpec(loc);
+ case token.VAR: return P.parseVarSpec(loc);
}
unreachable();
defer un(trace(P, "Decl"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(keyword);
if P.tok == token.LPAREN {
P.next();
list := vector.New(0);
for P.tok != token.RPAREN && P.tok != token.EOF {
- list.Push(P.parseSpec(0, keyword));
+ list.Push(P.parseSpec(noloc, keyword));
if P.tok == token.SEMICOLON {
P.next();
} else {
break;
}
}
- end := P.pos;
+ end := P.loc;
P.expect(token.RPAREN);
P.opt_semi = true;
decls[i] = list.At(i).(ast.Decl);
}
- return &ast.DeclList{pos, keyword, decls, end};
+ return &ast.DeclList{loc, keyword, decls, end};
}
- return P.parseSpec(pos, keyword);
+ return P.parseSpec(loc, keyword);
}
defer un(trace(P, "FunctionDecl"));
}
- pos := P.pos;
+ loc := P.loc;
P.expect(token.FUNC);
var recv *ast.Field;
if P.tok == token.LPAREN {
- pos := P.pos;
+ loc := P.loc;
tmp := P.parseParameters(true);
if len(tmp) == 1 {
recv = tmp[0];
} else {
- P.error(pos, "must have exactly one receiver");
+ P.error(loc, "must have exactly one receiver");
}
}
body = P.parseBlock(token.LBRACE);
}
- return &ast.FuncDecl{pos, recv, ident, sig, body};
+ return &ast.FuncDecl{loc, recv, ident, sig, body};
}
return P.parseFunctionDecl();
}
- pos := P.pos;
- P.error(pos, "declaration expected");
+ loc := P.loc;
+ P.error(loc, "declaration expected");
P.next(); // make progress
- return &ast.BadDecl{pos};
+ return &ast.BadDecl{loc};
}
defer un(trace(P, "Program"));
}
- p := ast.NewProgram(P.pos);
+ p := ast.NewProgram(P.loc);
p.Ident = P.ParsePackageClause();
// package body
"flag";
"fmt";
"strings";
- Utils "utils";
+ "utils";
"token";
+ "scanner";
"ast";
"template";
"utf8";
"unicode";
- SymbolTable "symboltable";
+ "symboltable";
)
var (
)
+// When we don't have a location use noloc.
+// TODO make sure we always have a location.
+var noloc scanner.Location;
+
+
// ----------------------------------------------------------------------------
// Elementary support
func (P *Printer) NextComment() {
P.cindex++;
if P.comments != nil && P.cindex < len(P.comments) {
- P.cpos = P.comments[P.cindex].Pos;
+ P.cpos = P.comments[P.cindex].Loc.Pos;
} else {
P.cpos = 1<<30; // infinite
}
}
-func (P *Printer) TaggedString(pos int, tag, s, endtag string) {
+func (P *Printer) TaggedString(loc scanner.Location, tag, s, endtag string) {
// use estimate for pos if we don't have one
+ pos := loc.Pos;
if pos == 0 {
pos = P.lastpos;
}
}
-func (P *Printer) String(pos int, s string) {
- P.TaggedString(pos, "", s, "");
+func (P *Printer) String(loc scanner.Location, s string) {
+ P.TaggedString(loc, "", s, "");
}
-func (P *Printer) Token(pos int, tok int) {
- P.String(pos, token.TokenString(tok));
+func (P *Printer) Token(loc scanner.Location, tok int) {
+ P.String(loc, token.TokenString(tok));
//P.TaggedString(pos, "<b>", token.TokenString(tok), "</b>");
}
-func (P *Printer) Error(pos int, tok int, msg string) {
- fmt.Printf("\ninternal printing error: pos = %d, tok = %s, %s\n", pos, token.TokenString(tok), msg);
+func (P *Printer) Error(loc scanner.Location, tok int, msg string) {
+ fmt.Printf("\ninternal printing error: pos = %d, tok = %s, %s\n", loc.Pos, token.TokenString(tok), msg);
panic();
}
// HTML support
func (P *Printer) HtmlIdentifier(x *ast.Ident) {
- P.String(x.Pos_, x.Str);
+ P.String(x.Loc_, x.Str);
/*
obj := x.Obj;
- if P.html && obj.Kind != SymbolTable.NONE {
+ if P.html && obj.Kind != symbolTable.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 {
+ id := utils.IntToString(obj.Id, 10);
+ if x.Loc_ == obj.Pos {
// probably the declaration of x
- P.TaggedString(x.
Pos_, `<a name="id` + id + `">`, obj.Ident, `</a>`);
+ P.TaggedString(x.
Loc_, `<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.
Loc_, `<a href="#id` + id + `">`, obj.Ident, `</a>`);
}
} else {
- P.String(x.Pos_, obj.Ident);
+ P.String(x.Loc_, obj.Ident);
}
*/
}
-func (P *Printer) HtmlPackageName(pos int, name string) {
+func (P *Printer) HtmlPackageName(loc scanner.Location, name string) {
if P.html {
sname := name[1 : len(name)-1]; // strip quotes TODO do this elsewhere eventually
// TODO CAPITAL HACK BELOW FIX THIS
- P.TaggedString(
pos, `"<a href="/src/lib/` + sname + `.go">`, sname, `</a>"`);
+ P.TaggedString(
loc, `"<a href="/src/lib/` + sname + `.go">`, sname, `</a>"`);
} else {
- P.String(pos, name);
+ P.String(loc, name);
}
}
func (P *Printer) Idents(list []*ast.Ident) {
for i, x := range list {
if i > 0 {
- P.Token(0, token.COMMA);
+ P.Token(noloc, token.COMMA);
P.separator = blank;
P.state = inside_list;
}
func (P *Printer) Parameters(list []*ast.Field) {
- P.Token(0, token.LPAREN);
+ P.Token(noloc, token.LPAREN);
if len(list) > 0 {
for i, par := range list {
if i > 0 {
P.Expr(par.Typ);
}
}
- P.Token(0, token.RPAREN);
+ P.Token(noloc, token.RPAREN);
}
}
-func (P *Printer) Fields(list []*ast.Field, end int, is_interface bool) {
+func (P *Printer) Fields(list []*ast.Field, end scanner.Location, is_interface bool) {
P.state = opening_scope;
P.separator = blank;
- P.Token(0, token.LBRACE);
+ P.Token(noloc, token.LBRACE);
if len(list) > 0 {
P.newlines = 1;
func (P *Printer) DoBadExpr(x *ast.BadExpr) {
- P.String(0, "BadExpr");
+ P.String(noloc, "BadExpr");
}
if x.Tok == token.COMMA {
// (don't use binary expression printing because of different spacing)
P.Expr(x.X);
- P.Token(x.Pos_, token.COMMA);
+ P.Token(x.Loc_, token.COMMA);
P.separator = blank;
P.state = inside_list;
P.Expr(x.Y);
} else {
prec := token.Precedence(x.Tok);
if prec < P.prec {
- P.Token(0, token.LPAREN);
+ P.Token(noloc, token.LPAREN);
}
P.Expr1(x.X, prec);
P.separator = blank;
- P.Token(x.Pos_, x.Tok);
+ P.Token(x.Loc_, x.Tok);
P.separator = blank;
P.Expr1(x.Y, prec);
if prec < P.prec {
- P.Token(0, token.RPAREN);
+ P.Token(noloc, token.RPAREN);
}
}
}
func (P *Printer) DoUnaryExpr(x *ast.UnaryExpr) {
prec := token.UnaryPrec;
if prec < P.prec {
- P.Token(0, token.LPAREN);
+ P.Token(noloc, token.LPAREN);
}
- P.Token(x.Pos_, x.Tok);
+ P.Token(x.Loc_, x.Tok);
if x.Tok == token.RANGE {
P.separator = blank;
}
P.Expr1(x.X, prec);
if prec < P.prec {
- P.Token(0, token.RPAREN);
+ P.Token(noloc, token.RPAREN);
}
}
func (P *Printer) DoBasicLit(x *ast.BasicLit) {
// TODO get rid of string conversion here
- P.String(x.Pos_, string(x.Val));
+ P.String(x.Loc_, string(x.Val));
}
func (P *Printer) DoFunctionLit(x *ast.FunctionLit) {
- P.Token(x.Pos_, token.FUNC);
+ P.Token(x.Loc_, token.FUNC);
P.Signature(x.Typ);
P.separator = blank;
P.Block(x.Body, true);
func (P *Printer) DoGroup(x *ast.Group) {
- P.Token(x.Pos_, token.LPAREN);
+ P.Token(x.Loc_, token.LPAREN);
P.Expr(x.X);
- P.Token(0, token.RPAREN);
+ P.Token(noloc, token.RPAREN);
}
func (P *Printer) DoSelector(x *ast.Selector) {
P.Expr1(x.X, token.HighestPrec);
- P.Token(x.Pos_, token.PERIOD);
+ P.Token(x.Loc_, token.PERIOD);
P.Expr1(x.Sel, token.HighestPrec);
}
func (P *Printer) DoTypeGuard(x *ast.TypeGuard) {
P.Expr1(x.X, token.HighestPrec);
- P.Token(x.Pos_, token.PERIOD);
- P.Token(0, token.LPAREN);
+ P.Token(x.Loc_, token.PERIOD);
+ P.Token(noloc, token.LPAREN);
P.Expr(x.Typ);
- P.Token(0, token.RPAREN);
+ P.Token(noloc, token.RPAREN);
}
func (P *Printer) DoIndex(x *ast.Index) {
P.Expr1(x.X, token.HighestPrec);
- P.Token(x.Pos_, token.LBRACK);
+ P.Token(x.Loc_, token.LBRACK);
P.Expr1(x.I, 0);
- P.Token(0, token.RBRACK);
+ P.Token(noloc, token.RBRACK);
}
func (P *Printer) DoCall(x *ast.Call) {
P.Expr1(x.F, token.HighestPrec);
- P.Token(x.Pos_, x.Tok);
+ P.Token(x.Loc_, x.Tok);
P.Expr(x.Args);
switch x.Tok {
- case token.LPAREN: P.Token(0, token.RPAREN);
- case token.LBRACE: P.Token(0, token.RBRACE);
+ case token.LPAREN: P.Token(noloc, token.RPAREN);
+ case token.LBRACE: P.Token(noloc, token.RBRACE);
}
}
func (P *Printer) DoEllipsis(x *ast.Ellipsis) {
- P.Token(x.Pos_, token.ELLIPSIS);
+ P.Token(x.Loc_, token.ELLIPSIS);
}
func (P *Printer) DoArrayType(x *ast.ArrayType) {
- P.Token(x.Pos_, token.LBRACK);
+ P.Token(x.Loc_, token.LBRACK);
if x.Len != nil {
P.Expr(x.Len);
}
- P.Token(0, token.RBRACK);
+ P.Token(noloc, token.RBRACK);
P.Expr(x.Elt);
}
func (P *Printer) DoTypeType(x *ast.TypeType) {
- P.Token(x.Pos_, token.TYPE);
+ P.Token(x.Loc_, token.TYPE);
}
func (P *Printer) DoStructType(x *ast.StructType) {
- P.Token(x.Pos_, token.STRUCT);
- if x.End > 0 {
+ P.Token(x.Loc_, token.STRUCT);
+ if x.End.Pos > 0 {
P.Fields(x.Fields, x.End, false);
}
}
func (P *Printer) DoPointerType(x *ast.PointerType) {
- P.Token(x.Pos_, token.MUL);
+ P.Token(x.Loc_, token.MUL);
P.Expr(x.Base);
}
func (P *Printer) DoFunctionType(x *ast.FunctionType) {
- P.Token(x.Pos_, token.FUNC);
+ P.Token(x.Loc_, token.FUNC);
P.Signature(x.Sig);
}
func (P *Printer) DoInterfaceType(x *ast.InterfaceType) {
- P.Token(x.Pos_, token.INTERFACE);
- if x.End > 0 {
+ P.Token(x.Loc_, token.INTERFACE);
+ if x.End.Pos > 0 {
P.Fields(x.Methods, x.End, true);
}
}
func (P *Printer) DoMapType(x *ast.MapType) {
- P.Token(x.Pos_, token.MAP);
+ P.Token(x.Loc_, token.MAP);
P.separator = blank;
- P.Token(0, token.LBRACK);
+ P.Token(noloc, token.LBRACK);
P.Expr(x.Key);
- P.Token(0, token.RBRACK);
+ P.Token(noloc, token.RBRACK);
P.Expr(x.Val);
}
func (P *Printer) DoChannelType(x *ast.ChannelType) {
switch x.Mode {
case ast.FULL:
- P.Token(x.Pos_, token.CHAN);
+ P.Token(x.Loc_, token.CHAN);
case ast.RECV:
- P.Token(x.Pos_, token.ARROW);
- P.Token(0, token.CHAN);
+ P.Token(x.Loc_, token.ARROW);
+ P.Token(noloc, token.CHAN);
case ast.SEND:
- P.Token(x.Pos_, token.CHAN);
+ P.Token(x.Loc_, token.CHAN);
P.separator = blank;
- P.Token(0, token.ARROW);
+ P.Token(noloc, token.ARROW);
}
P.separator = blank;
P.Expr(x.Val);
func (P *Printer) Block(b *ast.Block, indent bool) {
P.state = opening_scope;
- P.Token(b.Pos, b.Tok);
+ P.Token(b.Loc, b.Tok);
if !indent {
P.indentation--;
}
P.Token(b.End, token.RBRACE);
P.opt_semi = true;
} else {
- P.String(0, ""); // process closing_scope state transition!
+ P.String(noloc, ""); // process closing_scope state transition!
}
}
func (P *Printer) DoLabelDecl(s *ast.LabelDecl) {
P.indentation--;
P.Expr(s.Label);
- P.Token(s.Pos, token.COLON);
+ P.Token(s.Loc, token.COLON);
// TODO not quite correct:
// - we must not print this optional semicolon, as it may invalidate code.
// - this will change once the AST reflects the LabelStatement change
P.Expr(s.Expr);
case token.INC, token.DEC:
P.Expr(s.Expr);
- P.Token(s.Pos, s.Tok);
+ P.Token(s.Loc, s.Tok);
case token.RETURN, token.GO, token.DEFER:
- P.Token(s.Pos, s.Tok);
+ P.Token(s.Loc, s.Tok);
if s.Expr != nil {
P.separator = blank;
P.Expr(s.Expr);
}
default:
- P.Error(s.Pos, s.Tok, "DoExpressionStat");
+ P.Error(s.Loc, s.Tok, "DoExpressionStat");
unreachable();
}
}
P.Stat(init);
P.separator = none;
}
- P.Token(0, token.SEMICOLON);
+ P.Token(noloc, token.SEMICOLON);
P.separator = blank;
if expr != nil {
P.Expr(expr);
P.separator = none;
}
if isForStat {
- P.Token(0, token.SEMICOLON);
+ P.Token(noloc, token.SEMICOLON);
P.separator = blank;
if post != nil {
P.Stat(post);
func (P *Printer) DoIfStat(s *ast.IfStat) {
- P.Token(s.Pos, token.IF);
+ P.Token(s.Loc, token.IF);
P.ControlClause(false, s.Init, s.Cond, nil);
P.Block(s.Body, true);
if s.Else != nil {
P.separator = blank;
- P.Token(0, token.ELSE);
+ P.Token(noloc, token.ELSE);
P.separator = blank;
P.Stat(s.Else);
}
func (P *Printer) DoForStat(s *ast.ForStat) {
- P.Token(s.Pos, token.FOR);
+ P.Token(s.Loc, token.FOR);
P.ControlClause(true, s.Init, s.Cond, s.Post);
P.Block(s.Body, true);
}
func (P *Printer) DoCaseClause(s *ast.CaseClause) {
if s.Expr != nil {
- P.Token(s.Pos, token.CASE);
+ P.Token(s.Loc, token.CASE);
P.separator = blank;
P.Expr(s.Expr);
} else {
- P.Token(s.Pos, token.DEFAULT);
+ P.Token(s.Loc, token.DEFAULT);
}
// TODO: try to use P.Block instead
// P.Block(s.Body, true);
- P.Token(s.Body.Pos, token.COLON);
+ P.Token(s.Body.Loc, token.COLON);
P.indentation++;
P.StatementList(s.Body.List);
P.indentation--;
func (P *Printer) DoSwitchStat(s *ast.SwitchStat) {
- P.Token(s.Pos, token.SWITCH);
+ P.Token(s.Loc, token.SWITCH);
P.ControlClause(false, s.Init, s.Tag, nil);
P.Block(s.Body, false);
}
func (P *Printer) DoSelectStat(s *ast.SelectStat) {
- P.Token(s.Pos, token.SELECT);
+ P.Token(s.Loc, token.SELECT);
P.separator = blank;
P.Block(s.Body, false);
}
func (P *Printer) DoControlFlowStat(s *ast.ControlFlowStat) {
- P.Token(s.Pos, s.Tok);
+ P.Token(s.Loc, s.Tok);
if s.Label != nil {
P.separator = blank;
P.Expr(s.Label);
func (P *Printer) DoEmptyStat(s *ast.EmptyStat) {
- P.String(s.Pos, "");
+ P.String(s.Loc, "");
}
// Declarations
func (P *Printer) DoBadDecl(d *ast.BadDecl) {
- P.String(d.Pos, "<BAD DECL>");
+ P.String(d.Loc, "<BAD DECL>");
}
func (P *Printer) DoImportDecl(d *ast.ImportDecl) {
- if d.Pos > 0 {
- P.Token(d.Pos, token.IMPORT);
+ if d.Loc.Pos > 0 {
+ P.Token(d.Loc, token.IMPORT);
P.separator = blank;
}
if d.Ident != nil {
P.Expr(d.Ident);
} else {
- P.String(d.Path.Pos(), ""); // flush pending ';' separator/newlines
+ P.String(d.Path.Loc(), ""); // flush pending ';' separator/newlines
}
P.separator = tab;
if lit, is_lit := d.Path.(*ast.BasicLit); is_lit && lit.Tok == token.STRING {
- P.HtmlPackageName(lit.Pos_, string(lit.Val));
+ P.HtmlPackageName(lit.Loc_, string(lit.Val));
} else {
// we should only reach here for strange imports
// import "foo" "bar"
func (P *Printer) DoConstDecl(d *ast.ConstDecl) {
- if d.Pos > 0 {
- P.Token(d.Pos, token.CONST);
+ if d.Loc.Pos > 0 {
+ P.Token(d.Loc, token.CONST);
P.separator = blank;
}
P.Idents(d.Idents);
}
if d.Vals != nil {
P.separator = tab;
- P.Token(0, token.ASSIGN);
+ P.Token(noloc, token.ASSIGN);
P.separator = blank;
P.Expr(d.Vals);
}
func (P *Printer) DoTypeDecl(d *ast.TypeDecl) {
- if d.Pos > 0 {
- P.Token(d.Pos, token.TYPE);
+ if d.Loc.Pos > 0 {
+ P.Token(d.Loc, token.TYPE);
P.separator = blank;
}
P.Expr(d.Ident);
func (P *Printer) DoVarDecl(d *ast.VarDecl) {
- if d.Pos > 0 {
- P.Token(d.Pos, token.VAR);
+ if d.Loc.Pos > 0 {
+ P.Token(d.Loc, token.VAR);
P.separator = blank;
}
P.Idents(d.Idents);
}
if d.Vals != nil {
P.separator = tab;
- P.Token(0, token.ASSIGN);
+ P.Token(noloc, token.ASSIGN);
P.separator = blank;
P.Expr(d.Vals);
}
func (P *Printer) funcDecl(d *ast.FuncDecl, with_body bool) {
- P.Token(d.Pos, token.FUNC);
+ P.Token(d.Loc, token.FUNC);
P.separator = blank;
if recv := d.Recv; recv != nil {
// method: print receiver
- P.Token(0, token.LPAREN);
+ P.Token(noloc, token.LPAREN);
if len(recv.Idents) > 0 {
P.Expr(recv.Idents[0]);
P.separator = blank;
}
P.Expr(recv.Typ);
- P.Token(0, token.RPAREN);
+ P.Token(noloc, token.RPAREN);
P.separator = blank;
}
P.Expr(d.Ident);
func (P *Printer) DoDeclList(d *ast.DeclList) {
if !*def || d.Tok == token.IMPORT || d.Tok == token.VAR {
- P.Token(d.Pos, d.Tok);
+ P.Token(d.Loc, d.Tok);
} else {
- P.String(d.Pos, "def");
+ P.String(d.Loc, "def");
}
P.separator = blank;
// group of parenthesized declarations
P.state = opening_scope;
- P.Token(0, token.LPAREN);
+ P.Token(noloc, token.LPAREN);
if len(d.List) > 0 {
P.newlines = 1;
for i := 0; i < len(d.List); i++ {
/*
P.Printf("<p><code>");
P.funcDecl(d, false);
- P.String(0, "");
+ P.String(noloc, "");
P.Printf("</code></p>");
*/
}
// Program
func (P *Printer) Program(p *ast.Program) {
- P.Token(p.Pos, token.PACKAGE);
+ P.Token(p.Loc, token.PACKAGE);
P.separator = blank;
P.Expr(p.Ident);
P.newlines = 1;
P.Program(prog);
}
- P.String(0, ""); // flush pending separator/newlines
+ P.String(noloc, ""); // flush pending separator/newlines
err := text.Flush();
if err != nil {
panic("print error - exiting");
import (
"token";
- AST "ast";
+ "scanner";
+ "ast";
)
-type ErrorHandler interface {
- Error(pos int, msg string);
-}
-
-
type state struct {
// setup
- err ErrorHandler;
+ err scanner.ErrorHandler;
}
-func (s *state) Init(err ErrorHandler) {
+func (s *state) Init(err scanner.ErrorHandler) {
s.err = err;
}
}
-func (s *state) Error(pos int, msg string) {
- s.err.Error(pos, msg);
+func (s *state) Error(loc scanner.Location, msg string) {
+ s.err.Error(loc, msg);
}
*/
-func (s *state) CheckProgram(p *AST.Program) {
+func (s *state) CheckProgram(p *ast.Program) {
for i := 0; i < len(p.Decls); i++ {
//s.CheckDeclaration(p.Decls[i].(*AST.Decl));
}
// ----------------------------------------------------------------------------
-func CheckProgram(err ErrorHandler, p *AST.Program) {
+func CheckProgram(err scanner.ErrorHandler, p *ast.Program) {
var s state;
s.Init(err);
s.CheckProgram(p);