// provided via the Scanner interface. The output is an abstract syntax
// tree (AST) representing the Go source.
//
-// A client may parse the entire program (ParseProgram), only the package
-// clause (ParsePackageClause), or the package clause and the import
-// declarations (ParseImportDecls).
-//
-package Parser
+package parser
import (
"fmt";
"vector";
"token";
- "scanner";
"ast";
)
-// TODO rename Position to scanner.Position, possibly factor out
-type Position scanner.Location
-
-
type interval struct {
beg, end int;
}
-// 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.
+// An implementation of a Scanner must be provided to the Parser.
+// The parser calls Scan() repeatedly until token.EOF is returned.
+// Scan must return the current token position pos, the token value
+// tok, and the corresponding token literal string lit if the token
+// is a literal (i.e., if tok.IsLiteral() is true).
+//
+type Scanner interface {
+ Scan() (pos token.Position, tok token.Token, lit []byte);
+}
+
+
+// An implementation of an ErrorHandler must be provided to the parser.
+// If a syntax error is encountered, Error is called with a position and
+// an error message. The position points to the beginning of the offending
+// token.
//
-type Parser struct {
- scanner *scanner.Scanner;
- err scanner.ErrorHandler;
+type ErrorHandler interface {
+ Error(pos token.Position, msg string);
+}
+
+
+// The following flags control optional parser functionality. A set of
+// flags (or 0) must be provided as a parameter to the Parse function.
+//
+const (
+ Trace = 1 << iota;
+)
+
+
+// The parser structure holds the parser's internal state.
+type parser struct {
+ scanner Scanner;
+ err ErrorHandler;
// Tracing/debugging
trace bool;
last_doc interval; // last comments interval of consecutive comments
// The next token
- pos Position; // token location
+ pos token.Position; // token location
tok token.Token; // one token look-ahead
- val []byte; // token value
+ lit []byte; // token literal
// Non-syntactic parser control
opt_semi bool; // true if semicolon separator is optional in statement list
// When we don't have a location use nopos.
// TODO make sure we always have a location.
-var nopos Position;
+var nopos token.Position;
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Parsing support
-func (P *Parser) printIndent() {
+func (P *parser) printIndent() {
i := P.indent;
// reduce printing time by a factor of 2 or more
for ; i > 10; i -= 10 {
}
-func trace(P *Parser, msg string) *Parser {
+func trace(P *parser, msg string) *parser {
P.printIndent();
fmt.Printf("%s (\n", msg);
P.indent++;
}
-func un/*trace*/(P *Parser) {
+func un/*trace*/(P *parser) {
P.indent--;
P.printIndent();
fmt.Printf(")\n");
}
-func (P *Parser) next0() {
- P.pos, P.tok, P.val = P.scanner.Scan();
+func (P *parser) next0() {
+ P.pos, P.tok, P.lit = 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:%d: %s = %s\n", P.pos.Line, P.pos.Col, P.tok.String(), P.val);
+ fmt.Printf("%d:%d: %s = %s\n", P.pos.Line, P.pos.Column, P.tok.String(), P.lit);
case token.LPAREN:
// don't print '(' - screws up selection in terminal window
- fmt.Printf("%d:%d: LPAREN\n", P.pos.Line, P.pos.Col);
+ fmt.Printf("%d:%d: LPAREN\n", P.pos.Line, P.pos.Column);
case token.RPAREN:
// don't print ')' - screws up selection in terminal window
- fmt.Printf("%d:%d: RPAREN\n", P.pos.Line, P.pos.Col);
+ fmt.Printf("%d:%d: RPAREN\n", P.pos.Line, P.pos.Column);
default:
- fmt.Printf("%d:%d: %s\n", P.pos.Line, P.pos.Col, P.tok.String());
+ fmt.Printf("%d:%d: %s\n", P.pos.Line, P.pos.Column, P.tok.String());
}
}
}
// Collect a comment in the parser's comment list and return the line
// on which the comment ends.
-func (P *Parser) collectComment() int {
+func (P *parser) collectComment() int {
// For /*-style comments, the comment may end on a different line.
// Scan the comment for '\n' chars and adjust the end line accordingly.
// (Note that the position of the next token may be even further down
// as there may be more whitespace lines after the comment.)
endline := P.pos.Line;
- if P.val[1] == '*' {
- for i, b := range P.val {
+ if P.lit[1] == '*' {
+ for i, b := range P.lit {
if b == '\n' {
endline++;
}
}
}
- P.comments.Push(&ast.Comment{P.pos, P.val, endline});
+ P.comments.Push(&ast.Comment{P.pos, P.lit, endline});
P.next0();
return endline;
}
-func (P *Parser) getComments() interval {
+func (P *parser) getComments() interval {
// group adjacent comments, an empty line terminates a group
beg := P.comments.Len();
endline := P.pos.Line;
}
-func (P *Parser) next() {
+func (P *parser) next() {
P.next0();
P.last_doc = interval{0, 0};
for P.tok == token.COMMENT {
}
-func (P *Parser) Init(scanner *scanner.Scanner, err scanner.ErrorHandler, trace bool) {
- P.scanner = scanner;
- P.err = err;
- P.trace = trace;
- P.comments.Init(0);
- P.next();
-}
-
-
-func (P *Parser) error(pos Position, msg string) {
+func (P *parser) error(pos token.Position, msg string) {
P.err.Error(pos, msg);
}
-func (P *Parser) expect(tok token.Token) Position {
+func (P *parser) expect(tok token.Token) token.Position {
if P.tok != tok {
msg := "expected '" + tok.String() + "', found '" + P.tok.String() + "'";
if P.tok.IsLiteral() {
- msg += " " + string(P.val);
+ msg += " " + string(P.lit);
}
P.error(P.pos, msg);
}
}
-func (P *Parser) getDoc() ast.Comments {
+func (P *parser) getDoc() ast.Comments {
doc := P.last_doc;
n := doc.end - doc.beg;
// ----------------------------------------------------------------------------
// Common productions
-func (P *Parser) tryType() ast.Expr;
-func (P *Parser) parseExpression(prec int) ast.Expr;
-func (P *Parser) parseStatement() ast.Stmt;
-func (P *Parser) parseDeclaration() ast.Decl;
+func (P *parser) tryType() ast.Expr;
+func (P *parser) parseExpression(prec int) ast.Expr;
+func (P *parser) parseStatement() ast.Stmt;
+func (P *parser) parseDeclaration() ast.Decl;
-func (P *Parser) parseIdent() *ast.Ident {
+func (P *parser) parseIdent() *ast.Ident {
if P.trace {
defer un(trace(P, "Ident"));
}
if P.tok == token.IDENT {
- x := &ast.Ident{P.pos, P.val};
+ x := &ast.Ident{P.pos, P.lit};
P.next();
return x;
}
}
-func (P *Parser) parseIdentList(x ast.Expr) []*ast.Ident {
+func (P *parser) parseIdentList(x ast.Expr) []*ast.Ident {
if P.trace {
defer un(trace(P, "IdentList"));
}
}
-func (P *Parser) parseExpressionList() []ast.Expr {
+func (P *parser) parseExpressionList() []ast.Expr {
if P.trace {
defer un(trace(P, "ExpressionList"));
}
// ----------------------------------------------------------------------------
// Types
-func (P *Parser) parseType() ast.Expr {
+func (P *parser) parseType() ast.Expr {
if P.trace {
defer un(trace(P, "Type"));
}
}
-func (P *Parser) parseVarType() ast.Expr {
+func (P *parser) parseVarType() ast.Expr {
if P.trace {
defer un(trace(P, "VarType"));
}
}
-func (P *Parser) parseQualifiedIdent() ast.Expr {
+func (P *parser) parseQualifiedIdent() ast.Expr {
if P.trace {
defer un(trace(P, "QualifiedIdent"));
}
}
-func (P *Parser) parseTypeName() ast.Expr {
+func (P *parser) parseTypeName() ast.Expr {
if P.trace {
defer un(trace(P, "TypeName"));
}
}
-func (P *Parser) parseArrayType() *ast.ArrayType {
+func (P *parser) parseArrayType() *ast.ArrayType {
if P.trace {
defer un(trace(P, "ArrayType"));
}
}
-func (P *Parser) parseChannelType() *ast.ChannelType {
+func (P *parser) parseChannelType() *ast.ChannelType {
if P.trace {
defer un(trace(P, "ChannelType"));
}
}
-func (P *Parser) tryParameterType() ast.Expr {
+func (P *parser) tryParameterType() ast.Expr {
if P.tok == token.ELLIPSIS {
loc := P.pos;
P.next();
}
-func (P *Parser) parseParameterType() ast.Expr {
+func (P *parser) parseParameterType() ast.Expr {
typ := P.tryParameterType();
if typ == nil {
P.error(P.pos, "type expected");
}
-func (P *Parser) parseParameterDecl(ellipsis_ok bool) (*vector.Vector, ast.Expr) {
+func (P *parser) parseParameterDecl(ellipsis_ok bool) (*vector.Vector, ast.Expr) {
if P.trace {
defer un(trace(P, "ParameterDecl"));
}
}
-func (P *Parser) parseParameterList(ellipsis_ok bool) []*ast.Field {
+func (P *parser) parseParameterList(ellipsis_ok bool) []*ast.Field {
if P.trace {
defer un(trace(P, "ParameterList"));
}
// TODO make sure Go spec is updated
-func (P *Parser) parseParameters(ellipsis_ok bool) []*ast.Field {
+func (P *parser) parseParameters(ellipsis_ok bool) []*ast.Field {
if P.trace {
defer un(trace(P, "Parameters"));
}
}
-func (P *Parser) parseResult() []*ast.Field {
+func (P *parser) parseResult() []*ast.Field {
if P.trace {
defer un(trace(P, "Result"));
}
// (params) type
// (params) (results)
-func (P *Parser) parseSignature() (params []*ast.Field, results []*ast.Field) {
+func (P *parser) parseSignature() (params []*ast.Field, results []*ast.Field) {
if P.trace {
defer un(trace(P, "Signature"));
}
}
-func (P *Parser) parseFunctionType() *ast.FunctionType {
+func (P *parser) parseFunctionType() *ast.FunctionType {
if P.trace {
defer un(trace(P, "FunctionType"));
}
}
-func (P *Parser) parseMethodSpec() *ast.Field {
+func (P *parser) parseMethodSpec() *ast.Field {
if P.trace {
defer un(trace(P, "MethodSpec"));
}
}
-func (P *Parser) parseInterfaceType() *ast.InterfaceType {
+func (P *parser) parseInterfaceType() *ast.InterfaceType {
if P.trace {
defer un(trace(P, "InterfaceType"));
}
pos := P.expect(token.INTERFACE);
- var lbrace, rbrace Position;
+ var lbrace, rbrace token.Position;
var methods []*ast.Field;
if P.tok == token.LBRACE {
lbrace = P.pos;
}
-func (P *Parser) parseMapType() *ast.MapType {
+func (P *parser) parseMapType() *ast.MapType {
if P.trace {
defer un(trace(P, "MapType"));
}
}
-func (P *Parser) parseStringList(x *ast.StringLit) []*ast.StringLit
+func (P *parser) parseStringList(x *ast.StringLit) []*ast.StringLit
-func (P *Parser) parseFieldDecl() *ast.Field {
+func (P *parser) parseFieldDecl() *ast.Field {
if P.trace {
defer un(trace(P, "FieldDecl"));
}
}
-func (P *Parser) parseStructType() *ast.StructType {
+func (P *parser) parseStructType() *ast.StructType {
if P.trace {
defer un(trace(P, "StructType"));
}
pos := P.expect(token.STRUCT);
- var lbrace, rbrace Position;
+ var lbrace, rbrace token.Position;
var fields []*ast.Field;
if P.tok == token.LBRACE {
lbrace = P.pos;
}
-func (P *Parser) parsePointerType() *ast.StarExpr {
+func (P *parser) parsePointerType() *ast.StarExpr {
if P.trace {
defer un(trace(P, "PointerType"));
}
}
-func (P *Parser) tryType() ast.Expr {
+func (P *parser) tryType() ast.Expr {
if P.trace {
defer un(trace(P, "Type (try)"));
}
}
-func (P *Parser) parseStatementList() []ast.Stmt {
+func (P *parser) parseStatementList() []ast.Stmt {
if P.trace {
defer un(trace(P, "StatementList"));
}
}
-func (P *Parser) parseBlockStmt() *ast.BlockStmt {
+func (P *parser) parseBlockStmt() *ast.BlockStmt {
if P.trace {
defer un(trace(P, "compositeStmt"));
}
// ----------------------------------------------------------------------------
// Expressions
-func (P *Parser) parseFunctionLit() ast.Expr {
+func (P *parser) parseFunctionLit() ast.Expr {
if P.trace {
defer un(trace(P, "FunctionLit"));
}
}
-func (P *Parser) parseStringList(x *ast.StringLit) []*ast.StringLit {
+func (P *parser) parseStringList(x *ast.StringLit) []*ast.StringLit {
if P.trace {
defer un(trace(P, "StringList"));
}
}
for P.tok == token.STRING {
- list.Push(&ast.StringLit{P.pos, P.val});
+ list.Push(&ast.StringLit{P.pos, P.lit});
P.next();
}
}
-func (P *Parser) parseOperand() ast.Expr {
+func (P *parser) parseOperand() ast.Expr {
if P.trace {
defer un(trace(P, "Operand"));
}
return P.parseIdent();
case token.INT:
- x := &ast.IntLit{P.pos, P.val};
+ x := &ast.IntLit{P.pos, P.lit};
P.next();
return x;
case token.FLOAT:
- x := &ast.FloatLit{P.pos, P.val};
+ x := &ast.FloatLit{P.pos, P.lit};
P.next();
return x;
case token.CHAR:
- x := &ast.CharLit{P.pos, P.val};
+ x := &ast.CharLit{P.pos, P.lit};
P.next();
return x;
case token.STRING:
- x := &ast.StringLit{P.pos, P.val};
+ x := &ast.StringLit{P.pos, P.lit};
P.next();
if P.tok == token.STRING {
return &ast.StringList{P.parseStringList(x)};
}
-func (P *Parser) parseSelectorOrTypeAssertion(x ast.Expr) ast.Expr {
+func (P *parser) parseSelectorOrTypeAssertion(x ast.Expr) ast.Expr {
if P.trace {
defer un(trace(P, "SelectorOrTypeAssertion"));
}
var typ ast.Expr;
if P.tok == token.TYPE {
// special case for type switch syntax
- typ = &ast.Ident{P.pos, P.val};
+ typ = &ast.Ident{P.pos, P.lit};
P.next();
} else {
typ = P.parseType();
}
-func (P *Parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
+func (P *parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
if P.trace {
defer un(trace(P, "IndexOrSlice"));
}
}
-func (P *Parser) parseCall(fun ast.Expr) *ast.CallExpr {
+func (P *parser) parseCall(fun ast.Expr) *ast.CallExpr {
if P.trace {
defer un(trace(P, "Call"));
}
}
-func (P *Parser) parseElementList() []ast.Expr {
+func (P *parser) parseElementList() []ast.Expr {
if P.trace {
defer un(trace(P, "ElementList"));
}
x := P.parseExpression(0);
if list.Len() == 0 {
// first element determines syntax for remaining elements
- if t, is_binary := x.(*ast.BinaryExpr); is_binary && t.Tok == token.COLON {
+ if t, is_binary := x.(*ast.BinaryExpr); is_binary && t.Op == token.COLON {
singles = false;
}
} else {
// not the first element - check syntax
if singles {
- if t, is_binary := x.(*ast.BinaryExpr); is_binary && t.Tok == token.COLON {
+ if t, is_binary := x.(*ast.BinaryExpr); is_binary && t.Op == token.COLON {
P.error(t.X.Pos(), "single value expected; found pair");
}
} else {
- if t, is_binary := x.(*ast.BinaryExpr); !is_binary || t.Tok != token.COLON {
+ if t, is_binary := x.(*ast.BinaryExpr); !is_binary || t.Op != token.COLON {
P.error(x.Pos(), "key:value pair expected; found single value");
}
}
}
-func (P *Parser) parseCompositeLit(typ ast.Expr) ast.Expr {
+func (P *parser) parseCompositeLit(typ ast.Expr) ast.Expr {
if P.trace {
defer un(trace(P, "CompositeLit"));
}
}
-func (P *Parser) parsePrimaryExpr() ast.Expr {
+func (P *parser) parsePrimaryExpr() ast.Expr {
if P.trace {
defer un(trace(P, "PrimaryExpr"));
}
}
-func (P *Parser) parseUnaryExpr() ast.Expr {
+func (P *parser) parseUnaryExpr() ast.Expr {
if P.trace {
defer un(trace(P, "UnaryExpr"));
}
}
-func (P *Parser) parseBinaryExpr(prec1 int) ast.Expr {
+func (P *parser) parseBinaryExpr(prec1 int) ast.Expr {
if P.trace {
defer un(trace(P, "BinaryExpr"));
}
}
-func (P *Parser) parseExpression(prec int) ast.Expr {
+func (P *parser) parseExpression(prec int) ast.Expr {
if P.trace {
defer un(trace(P, "Expression"));
}
// Statements
-func (P *Parser) parseSimpleStmt() ast.Stmt {
+func (P *parser) parseSimpleStmt() ast.Stmt {
if P.trace {
defer un(trace(P, "SimpleStmt"));
}
}
-func (P *Parser) parseCallExpr() *ast.CallExpr {
+func (P *parser) parseCallExpr() *ast.CallExpr {
x := P.parseExpression(1);
if call, is_call := x.(*ast.CallExpr); is_call {
return call;
}
-func (P *Parser) parseGoStmt() ast.Stmt {
+func (P *parser) parseGoStmt() ast.Stmt {
if P.trace {
defer un(trace(P, "GoStmt"));
}
}
-func (P *Parser) parseDeferStmt() ast.Stmt {
+func (P *parser) parseDeferStmt() ast.Stmt {
if P.trace {
defer un(trace(P, "DeferStmt"));
}
}
-func (P *Parser) parseReturnStmt() *ast.ReturnStmt {
+func (P *parser) parseReturnStmt() *ast.ReturnStmt {
if P.trace {
defer un(trace(P, "ReturnStmt"));
}
}
-func (P *Parser) parseBranchStmt(tok token.Token) *ast.BranchStmt {
+func (P *parser) parseBranchStmt(tok token.Token) *ast.BranchStmt {
if P.trace {
defer un(trace(P, "BranchStmt"));
}
}
-func (P *Parser) isExpr(s ast.Stmt) bool {
+func (P *parser) isExpr(s ast.Stmt) bool {
if s == nil {
return true;
}
}
-func (P *Parser) asExpr(s ast.Stmt) ast.Expr {
+func (P *parser) asExpr(s ast.Stmt) ast.Expr {
if s == nil {
return nil;
}
}
-func (P *Parser) parseControlClause(isForStmt bool) (s1, s2, s3 ast.Stmt) {
+func (P *parser) parseControlClause(isForStmt bool) (s1, s2, s3 ast.Stmt) {
if P.trace {
defer un(trace(P, "ControlClause"));
}
}
-func (P *Parser) parseIfStmt() *ast.IfStmt {
+func (P *parser) parseIfStmt() *ast.IfStmt {
if P.trace {
defer un(trace(P, "IfStmt"));
}
}
-func (P *Parser) parseCaseClause() *ast.CaseClause {
+func (P *parser) parseCaseClause() *ast.CaseClause {
if P.trace {
defer un(trace(P, "CaseClause"));
}
}
-func (P *Parser) parseTypeCaseClause() *ast.TypeCaseClause {
+func (P *parser) parseTypeCaseClause() *ast.TypeCaseClause {
if P.trace {
defer un(trace(P, "CaseClause"));
}
}
-func (P *Parser) parseSwitchStmt() ast.Stmt {
+func (P *parser) parseSwitchStmt() ast.Stmt {
if P.trace {
defer un(trace(P, "SwitchStmt"));
}
}
-func (P *Parser) parseCommClause() *ast.CommClause {
+func (P *parser) parseCommClause() *ast.CommClause {
if P.trace {
defer un(trace(P, "CommClause"));
}
}
-func (P *Parser) parseSelectStmt() *ast.SelectStmt {
+func (P *parser) parseSelectStmt() *ast.SelectStmt {
if P.trace {
defer un(trace(P, "SelectStmt"));
}
}
-func (P *Parser) parseForStmt() ast.Stmt {
+func (P *parser) parseForStmt() ast.Stmt {
if P.trace {
defer un(trace(P, "ForStmt"));
}
if as, is_as := s2.(*ast.AssignStmt); is_as {
// possibly a for statement with a range clause; check assignment operator
if as.Tok != token.ASSIGN && as.Tok != token.DEFINE {
- P.error(as.Pos_, "'=' or ':=' expected");
+ P.error(as.TokPos, "'=' or ':=' expected");
return &ast.BadStmt{pos};
}
// check lhs
P.error(as.Rhs[0].Pos(), "expected 1 expressions");
return &ast.BadStmt{pos};
}
- if rhs, is_unary := as.Rhs[0].(*ast.UnaryExpr); is_unary && rhs.Tok == token.RANGE {
+ if rhs, is_unary := as.Rhs[0].(*ast.UnaryExpr); is_unary && rhs.Op == token.RANGE {
// rhs is range expression; check lhs
- return &ast.RangeStmt{pos, key, value, as.Pos_, as.Tok, rhs.X, body}
+ return &ast.RangeStmt{pos, key, value, as.TokPos, as.Tok, rhs.X, body}
} else {
P.error(s2.Pos(), "range clause expected");
return &ast.BadStmt{pos};
}
-func (P *Parser) parseStatement() ast.Stmt {
+func (P *parser) parseStatement() ast.Stmt {
if P.trace {
defer un(trace(P, "Statement"));
}
// ----------------------------------------------------------------------------
// Declarations
-func (P *Parser) parseImportSpec(pos Position, doc ast.Comments) *ast.ImportDecl {
+func (P *parser) parseImportSpec(pos token.Position, doc ast.Comments) *ast.ImportDecl {
if P.trace {
defer un(trace(P, "ImportSpec"));
}
}
-func (P *Parser) parseConstSpec(pos Position, doc ast.Comments) *ast.ConstDecl {
+func (P *parser) parseConstSpec(pos token.Position, doc ast.Comments) *ast.ConstDecl {
if P.trace {
defer un(trace(P, "ConstSpec"));
}
}
-func (P *Parser) parseTypeSpec(pos Position, doc ast.Comments) *ast.TypeDecl {
+func (P *parser) parseTypeSpec(pos token.Position, doc ast.Comments) *ast.TypeDecl {
if P.trace {
defer un(trace(P, "TypeSpec"));
}
}
-func (P *Parser) parseVarSpec(pos Position, doc ast.Comments) *ast.VarDecl {
+func (P *parser) parseVarSpec(pos token.Position, doc ast.Comments) *ast.VarDecl {
if P.trace {
defer un(trace(P, "VarSpec"));
}
}
-func (P *Parser) parseSpec(pos Position, doc ast.Comments, keyword int) ast.Decl {
+func (P *parser) parseSpec(pos token.Position, doc ast.Comments, keyword int) ast.Decl {
switch keyword {
case token.IMPORT: return P.parseImportSpec(pos, doc);
case token.CONST: return P.parseConstSpec(pos, doc);
}
-func (P *Parser) parseDecl(keyword int) ast.Decl {
+func (P *parser) parseDecl(keyword int) ast.Decl {
if P.trace {
defer un(trace(P, "Decl"));
}
// func (recv) ident (params) type
// func (recv) ident (params) (results)
-func (P *Parser) parseFunctionDecl() *ast.FuncDecl {
+func (P *parser) parseFunctionDecl() *ast.FuncDecl {
if P.trace {
defer un(trace(P, "FunctionDecl"));
}
}
-func (P *Parser) parseDeclaration() ast.Decl {
+func (P *parser) parseDeclaration() ast.Decl {
if P.trace {
defer un(trace(P, "Declaration"));
}
// ----------------------------------------------------------------------------
-// Program
+// Packages
-// The Parse function is parametrized with one of the following
-// constants. They control how much of the source text is parsed.
-//
+// The Mode constants control how much of the source text is parsed.
+type Mode int;
const (
- ParseEntirePackage = iota;
+ ParseEntirePackage Mode = iota;
ParseImportDeclsOnly;
ParsePackageClauseOnly;
)
-// Parse parses the source...
-//
-// foo bar
-//
-func (P *Parser) Parse(mode int) *ast.Package {
+func (P *parser) parsePackage(mode Mode) *ast.Package {
if P.trace {
defer un(trace(P, "Program"));
}
return &ast.Package{comment, pos, name, decls, comments};
}
+
+
+// ----------------------------------------------------------------------------
+// Parsing of entire programs.
+
+// Parse invokes the Go parser. It calls the scanner's Scan method repeatedly
+// to obtain the token sequence corresponding to the source code. The sequence
+// is parsed according to Go syntax and the corresponding abstract syntax tree
+// is constructed. The error handler err will be used to report syntax errors.
+//
+// If no syntax errors were encountered (i.e., if the error handler was never
+// called), the result is a correct AST. If errors were encountered, the AST
+// may only be constructed partially, with ast.BadX nodes representing the
+// fragments of source code that contained syntax errors.
+//
+// The amount of source text parsed can be controlled with the mode parameter.
+// The flags parameter controls optional parser functionality such as tracing.
+//
+func Parse(scanner Scanner, err ErrorHandler, mode Mode, flags uint) *ast.Package {
+ // initialize parser state
+ var p parser;
+ p.scanner = scanner;
+ p.err = err;
+ p.trace = flags & Trace != 0;
+ p.comments.Init(0);
+ p.next();
+
+ // parse program
+ return p.parsePackage(mode);
+}
)
-// When we don't have a location use nopos.
-// TODO make sure we always have a location.
-var nopos scanner.Location;
+// When we don't have a position use nopos.
+// TODO make sure we always have a position.
+var nopos token.Position;
// ----------------------------------------------------------------------------
// comments
comments []*ast.Comment; // the list of unassociated comments
cindex int; // the current comment group index
- cloc scanner.Location; // the position of the next comment group
+ cpos token.Position; // the position of the next comment group
// current state
- lastloc scanner.Location; // location after last string
+ lastpos token.Position; // position after last string
level int; // scope level
indentation int; // indentation level (may be different from scope level)
}
-func (P *Printer) hasComment(loc scanner.Location) bool {
- return *comments && P.cloc.Pos < loc.Pos;
+func (P *Printer) hasComment(pos token.Position) bool {
+ return *comments && P.cpos.Offset < pos.Offset;
}
func (P *Printer) nextComments() {
P.cindex++;
if P.comments != nil && P.cindex < len(P.comments) && P.comments[P.cindex] != nil {
- P.cloc = P.comments[P.cindex].Pos_;
+ P.cpos = P.comments[P.cindex].Pos();
} else {
- P.cloc = scanner.Location{1<<30, 1<<30, 1}; // infinite
+ P.cpos = token.Position{1<<30, 1<<30, 1}; // infinite
}
}
}
-func (P *Printer) TaggedString(loc scanner.Location, tag, s, endtag string) {
+func (P *Printer) TaggedString(pos token.Position, tag, s, endtag string) {
// use estimate for pos if we don't have one
- pos := loc.Pos;
- if pos == 0 {
- pos = P.lastloc.Pos;
+ offs := pos.Offset;
+ if offs == 0 {
+ offs = P.lastpos.Offset;
}
// --------------------------------
// interleave comments, if any
nlcount := 0;
if P.full {
- for ; P.hasComment(loc); P.nextComments() {
+ for ; P.hasComment(pos); P.nextComments() {
// we have a comment group that comes before the string
comment := P.comments[P.cindex];
ctext := string(comment.Text); // TODO get rid of string conversion here
// classify comment (len(ctext) >= 2)
//-style comment
- if nlcount > 0 || P.cloc.Pos == 0 {
+ if nlcount > 0 || P.cpos.Offset == 0 {
// only white space before comment on this line
// or file starts with comment
// - indent
- if !*newlines && P.cloc.Pos != 0 {
+ if !*newlines && P.cpos.Offset != 0 {
nlcount = 1;
}
P.newline(nlcount);
// print comment
if *debug {
- P.Printf("[%d]", P.cloc.Pos);
+ P.Printf("[%d]", P.cpos.Offset);
}
// calling untabify increases the change for idempotent output
// since tabs in comments are also interpreted by tabwriter
// --------------------------------
// done
P.opt_semi = false;
- loc.Pos += len(s); // rough estimate
- loc.Col += len(s); // rough estimate
- P.lastloc = loc;
+ pos.Offset += len(s); // rough estimate
+ pos.Column += len(s); // rough estimate
+ P.lastpos = pos;
}
-func (P *Printer) String(loc scanner.Location, s string) {
- P.TaggedString(loc, "", s, "");
+func (P *Printer) String(pos token.Position, s string) {
+ P.TaggedString(pos, "", s, "");
}
-func (P *Printer) Token(loc scanner.Location, tok token.Token) {
- P.String(loc, tok.String());
+func (P *Printer) Token(pos token.Position, tok token.Token) {
+ P.String(pos, tok.String());
//P.TaggedString(pos, "<b>", tok.String(), "</b>");
}
-func (P *Printer) Error(loc scanner.Location, tok token.Token, msg string) {
- fmt.Printf("\ninternal printing error: pos = %d, tok = %s, %s\n", loc.Pos, tok.String(), msg);
+func (P *Printer) Error(pos token.Position, tok token.Token, msg string) {
+ fmt.Printf("\ninternal printing error: pos = %d, tok = %s, %s\n", pos.Offset, tok.String(), msg);
panic();
}
// HTML support
func (P *Printer) HtmlIdentifier(x *ast.Ident) {
- P.String(x.Pos_, string(x.Lit));
+ P.String(x.Pos(), string(x.Lit));
/*
obj := x.Obj;
if P.html && obj.Kind != symbolTable.NONE {
}
-func (P *Printer) HtmlPackageName(loc scanner.Location, name string) {
+func (P *Printer) HtmlPackageName(pos token.Position, 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(
loc, `"<a href="/src/lib/` + sname + `.go">`, sname, `</a>"`);
+ P.TaggedString(
pos, `"<a href="/src/lib/` + sname + `.go">`, sname, `</a>"`);
} else {
- P.String(loc, name);
+ P.String(pos, name);
}
}
}
-func (P *Printer) Fields(lbrace scanner.Location, list []*ast.Field, rbrace scanner.Location, is_interface bool) {
+func (P *Printer) Fields(lbrace token.Position, list []*ast.Field, rbrace token.Position, is_interface bool) {
P.state = opening_scope;
P.separator = blank;
P.Token(lbrace, token.LBRACE);
func (P *Printer) DoBinaryExpr(x *ast.BinaryExpr) {
- prec := x.Tok.Precedence();
+ prec := x.Op.Precedence();
if prec < P.prec {
P.Token(nopos, token.LPAREN);
}
P.Expr1(x.X, prec);
P.separator = blank;
- P.Token(x.Pos_, x.Tok);
+ P.Token(x.OpPos, x.Op);
P.separator = blank;
P.Expr1(x.Y, prec);
if prec < P.prec {
func (P *Printer) DoStarExpr(x *ast.StarExpr) {
- P.Token(x.Star, token.MUL);
+ P.Token(x.Pos(), token.MUL);
P.Expr(x.X);
}
if prec < P.prec {
P.Token(nopos, token.LPAREN);
}
- P.Token(x.Pos_, x.Tok);
- if x.Tok == token.RANGE {
+ P.Token(x.Pos(), x.Op);
+ if x.Op == token.RANGE {
P.separator = blank;
}
P.Expr1(x.X, prec);
func (P *Printer) DoIntLit(x *ast.IntLit) {
// TODO get rid of string conversion here
- P.String(x.Pos_, string(x.Lit));
+ P.String(x.Pos(), string(x.Lit));
}
func (P *Printer) DoFloatLit(x *ast.FloatLit) {
// TODO get rid of string conversion here
- P.String(x.Pos_, string(x.Lit));
+ P.String(x.Pos(), string(x.Lit));
}
func (P *Printer) DoCharLit(x *ast.CharLit) {
// TODO get rid of string conversion here
- P.String(x.Pos_, string(x.Lit));
+ P.String(x.Pos(), string(x.Lit));
}
func (P *Printer) DoStringLit(x *ast.StringLit) {
// TODO get rid of string conversion here
- P.String(x.Pos_, string(x.Lit));
+ P.String(x.Pos(), string(x.Lit));
}
func (P *Printer) DoParenExpr(x *ast.ParenExpr) {
- P.Token(x.Lparen, token.LPAREN);
+ P.Token(x.Pos(), token.LPAREN);
P.Expr(x.X);
P.Token(x.Rparen, token.RPAREN);
}
func (P *Printer) DoEllipsis(x *ast.Ellipsis) {
- P.Token(x.Pos_, token.ELLIPSIS);
+ P.Token(x.Pos(), token.ELLIPSIS);
}
func (P *Printer) DoArrayType(x *ast.ArrayType) {
- P.Token(x.Lbrack, token.LBRACK);
+ P.Token(x.Pos(), token.LBRACK);
if x.Len != nil {
P.Expr(x.Len);
}
func (P *Printer) DoStructType(x *ast.StructType) {
- P.Token(x.Struct, token.STRUCT);
+ P.Token(x.Pos(), token.STRUCT);
if x.Fields != nil {
P.Fields(x.Lbrace, x.Fields, x.Rbrace, false);
}
func (P *Printer) DoFunctionType(x *ast.FunctionType) {
- P.Token(x.Func, token.FUNC);
+ P.Token(x.Pos(), token.FUNC);
P.Signature(x.Params, x.Results);
}
func (P *Printer) DoInterfaceType(x *ast.InterfaceType) {
- P.Token(x.Interface, token.INTERFACE);
+ P.Token(x.Pos(), token.INTERFACE);
if x.Methods != nil {
P.Fields(x.Lbrace, x.Methods, x.Rbrace, true);
}
func (P *Printer) DoMapType(x *ast.MapType) {
- P.Token(x.Map, token.MAP);
+ P.Token(x.Pos(), token.MAP);
P.separator = blank;
P.Token(nopos, token.LBRACK);
P.Expr(x.Key);
func (P *Printer) DoChannelType(x *ast.ChannelType) {
switch x.Dir {
case ast.SEND | ast.RECV:
- P.Token(x.Pos_, token.CHAN);
+ P.Token(x.Pos(), token.CHAN);
case ast.RECV:
- P.Token(x.Pos_, token.ARROW);
+ P.Token(x.Pos(), token.ARROW);
P.Token(nopos, token.CHAN);
case ast.SEND:
- P.Token(x.Pos_, token.CHAN);
+ P.Token(x.Pos(), token.CHAN);
P.separator = blank;
P.Token(nopos, token.ARROW);
}
func (P *Printer) DoEmptyStmt(s *ast.EmptyStmt) {
- P.String(s.Semicolon, "");
+ P.String(s.Pos(), "");
}
func (P *Printer) DoAssignStmt(s *ast.AssignStmt) {
P.Exprs(s.Lhs);
P.separator = blank;
- P.Token(s.Pos_, s.Tok);
+ P.Token(s.TokPos, s.Tok);
P.separator = blank;
P.Exprs(s.Rhs);
}
func (P *Printer) DoGoStmt(s *ast.GoStmt) {
- P.Token(s.Go, token.GO);
+ P.Token(s.Pos(), token.GO);
P.separator = blank;
P.Expr(s.Call);
}
func (P *Printer) DoDeferStmt(s *ast.DeferStmt) {
- P.Token(s.Defer, token.DEFER);
+ P.Token(s.Pos(), token.DEFER);
P.separator = blank;
P.Expr(s.Call);
}
func (P *Printer) DoReturnStmt(s *ast.ReturnStmt) {
- P.Token(s.Return, token.RETURN);
+ P.Token(s.Pos(), token.RETURN);
P.separator = blank;
P.Exprs(s.Results);
}
func (P *Printer) DoBranchStmt(s *ast.BranchStmt) {
- P.Token(s.Pos_, s.Tok);
+ P.Token(s.Pos(), s.Tok);
if s.Label != nil {
P.separator = blank;
P.Expr(s.Label);
func (P *Printer) DoBlockStmt(s *ast.BlockStmt) {
P.state = opening_scope;
- P.Token(s.Lbrace, token.LBRACE);
+ P.Token(s.Pos(), token.LBRACE);
P.StatementList(s.List);
if !*optsemicolons {
P.separator = none;
func (P *Printer) DoIfStmt(s *ast.IfStmt) {
- P.Token(s.If, token.IF);
+ P.Token(s.Pos(), token.IF);
P.ControlClause(false, s.Init, s.Cond, nil);
P.Stmt(s.Body);
if s.Else != nil {
func (P *Printer) DoCaseClause(s *ast.CaseClause) {
if s.Values != nil {
- P.Token(s.Case, token.CASE);
+ P.Token(s.Pos(), token.CASE);
P.separator = blank;
P.Exprs(s.Values);
} else {
- P.Token(s.Case, token.DEFAULT);
+ P.Token(s.Pos(), token.DEFAULT);
}
P.Token(s.Colon, token.COLON);
P.indentation++;
func (P *Printer) DoSwitchStmt(s *ast.SwitchStmt) {
- P.Token(s.Switch, token.SWITCH);
+ P.Token(s.Pos(), token.SWITCH);
P.ControlClause(false, s.Init, s.Tag, nil);
P.Stmt(s.Body);
}
func (P *Printer) DoTypeCaseClause(s *ast.TypeCaseClause) {
if s.Type != nil {
- P.Token(s.Case, token.CASE);
+ P.Token(s.Pos(), token.CASE);
P.separator = blank;
P.Expr(s.Type);
} else {
- P.Token(s.Case, token.DEFAULT);
+ P.Token(s.Pos(), token.DEFAULT);
}
P.Token(s.Colon, token.COLON);
P.indentation++;
func (P *Printer) DoTypeSwitchStmt(s *ast.TypeSwitchStmt) {
- P.Token(s.Switch, token.SWITCH);
+ P.Token(s.Pos(), token.SWITCH);
P.separator = blank;
if s.Init != nil {
P.Stmt(s.Init);
func (P *Printer) DoCommClause(s *ast.CommClause) {
if s.Rhs != nil {
- P.Token(s.Case, token.CASE);
+ P.Token(s.Pos(), token.CASE);
P.separator = blank;
if s.Lhs != nil {
P.Expr(s.Lhs);
}
P.Expr(s.Rhs);
} else {
- P.Token(s.Case, token.DEFAULT);
+ P.Token(s.Pos(), token.DEFAULT);
}
P.Token(s.Colon, token.COLON);
P.indentation++;
func (P *Printer) DoSelectStmt(s *ast.SelectStmt) {
- P.Token(s.Select, token.SELECT);
+ P.Token(s.Pos(), token.SELECT);
P.separator = blank;
P.Stmt(s.Body);
}
func (P *Printer) DoForStmt(s *ast.ForStmt) {
- P.Token(s.For, token.FOR);
+ P.Token(s.Pos(), token.FOR);
P.ControlClause(true, s.Init, s.Cond, s.Post);
P.Stmt(s.Body);
}
func (P *Printer) DoRangeStmt(s *ast.RangeStmt) {
- P.Token(s.For, token.FOR);
+ P.Token(s.Pos(), token.FOR);
P.separator = blank;
P.Expr(s.Key);
if s.Value != nil {
P.Expr(s.Value);
}
P.separator = blank;
- P.Token(s.Pos_, s.Tok);
+ P.Token(s.TokPos, s.Tok);
P.separator = blank;
P.Token(nopos, token.RANGE);
P.separator = blank;
// Declarations
func (P *Printer) DoBadDecl(d *ast.BadDecl) {
- P.String(d.Pos_, "<BAD DECL>");
+ P.String(d.Pos(), "<BAD DECL>");
}
func (P *Printer) DoImportDecl(d *ast.ImportDecl) {
- if d.Import.Pos > 0 {
- P.Token(d.Import, token.IMPORT);
+ if d.Pos().Offset > 0 {
+ P.Token(d.Pos(), token.IMPORT);
P.separator = blank;
}
if d.Name != nil {
func (P *Printer) DoConstDecl(d *ast.ConstDecl) {
- if d.Const.Pos > 0 {
- P.Token(d.Const, token.CONST);
+ if d.Pos().Offset > 0 {
+ P.Token(d.Pos(), token.CONST);
P.separator = blank;
}
P.Idents(d.Names, P.full);
func (P *Printer) DoTypeDecl(d *ast.TypeDecl) {
- if d.Pos_.Pos > 0 {
- P.Token(d.Pos_, token.TYPE);
+ if d.Pos().Offset > 0 {
+ P.Token(d.Pos(), token.TYPE);
P.separator = blank;
}
P.Expr(d.Name);
func (P *Printer) DoVarDecl(d *ast.VarDecl) {
- if d.Var.Pos > 0 {
- P.Token(d.Var, token.VAR);
+ if d.Pos().Offset > 0 {
+ P.Token(d.Pos(), token.VAR);
P.separator = blank;
}
P.Idents(d.Names, P.full);
func (P *Printer) DoFuncDecl(d *ast.FuncDecl) {
- P.Token(d.Type.Func, token.FUNC);
+ P.Token(d.Pos(), token.FUNC);
P.separator = blank;
if recv := d.Recv; recv != nil {
// method: print receiver
func (P *Printer) DoDeclList(d *ast.DeclList) {
- P.Token(d.Pos_, d.Tok);
+ P.Token(d.Pos(), d.Tok);
P.separator = blank;
// group of parenthesized declarations
func (P *Printer) Program(p *ast.Package) {
P.full = true;
- P.Token(p.Package, token.PACKAGE);
+ P.Token(p.Pos(), token.PACKAGE);
P.separator = blank;
P.Expr(p.Name);
P.newlines = 1;