}
func PackageImports(file string) (pkg string, imports []string, err1 os.Error) {
- f, err := os.Open(file, os.O_RDONLY, 0);
- if err != nil {
- return "", nil, err
- }
-
- prog, err := parser.Parse(file, f, parser.ImportsOnly);
+ prog, err := parser.ParseFile(file, nil, parser.ImportsOnly);
if err != nil {
return "", nil, err;
}
// Parses a file (path) and returns the corresponding AST and
// a sorted list (by file position) of errors, if any.
//
-func parse(path string, mode uint) (*ast.Program, *parseErrors) {
+func parse(path string, mode uint) (*ast.File, *parseErrors) {
src, err := io.ReadFile(path);
if err != nil {
log.Stderrf("ReadFile %s: %v", path, err);
return nil, &parseErrors{path, errs, nil};
}
- prog, err := parser.Parse(path, src, mode);
+ prog, err := parser.ParseFile(path, src, mode);
if err != nil {
var errs []parseError;
if errors, ok := err.(scanner.ErrorList); ok {
var buf bytes.Buffer;
tw := makeTabwriter(&buf);
mode := uint(0);
- if _, isProgram := node.(*ast.Program); isProgram {
+ if _, isProgram := node.(*ast.File); isProgram {
mode = printer.DocComments;
}
printer.Fprint(tw, node, mode);
return;
}
- // the package name is is the directory name within its parent
+ // the package name is the directory name within its parent
_, pakname := pathutil.Split(dirname);
// collect all files belonging to the package and count the
}
// compute documentation
+ // TODO(gri) change doc to work on entire ast.Package at once
var r doc.DocReader;
i := 0;
for filename := range p.filenames {
- prog, err := parse(p.dirname + "/" + filename, parser.ParseComments);
+ src, err := parse(p.dirname + "/" + filename, parser.ParseComments);
if err != nil {
return nil, err;
}
if i == 0 {
// first file - initialize doc
- r.Init(prog.Name.Value, p.importpath);
+ r.Init(src.Name.Value, p.importpath);
}
i++;
- ast.FilterExports(prog); // we only care about exports
- r.AddProgram(prog);
+ ast.FilterExports(src); // we only care about exports
+ r.AddFile(src);
}
return r.Doc(), nil;
" godoc -http=:6060\n"
);
flag.PrintDefaults();
- os.Exit(1);
+ os.Exit(2);
}
func main() {
+ flag.Usage = usage;
flag.Parse();
// Check usage first; get usage message out early.
"go/scanner";
"io";
"os";
+ pathutil "path";
"sort";
+ "strings";
"tabwriter";
)
+const pkgDir = "src/pkg"; // relative to $GOROOT
+
+
var (
+ goroot = flag.String("goroot", os.Getenv("GOROOT"), "Go root directory");
+
// operation modes
+ allgo = flag.Bool("a", false, "include all .go files for package");
silent = flag.Bool("s", false, "silent mode: parsing only");
verbose = flag.Bool("v", false, "verbose mode: trace parsing");
exports = flag.Bool("x", false, "show exports only");
func usage() {
- fmt.Fprintf(os.Stderr, "usage: gofmt [flags] [file.go]\n");
+ fmt.Fprintf(os.Stderr, "usage: gofmt [flags] [file.go | pkgpath]\n");
flag.PrintDefaults();
- os.Exit(1);
+ os.Exit(2);
}
}
+func isPkgFile(filename string) bool {
+ // ignore non-Go files
+ if strings.HasPrefix(filename, ".") || !strings.HasSuffix(filename, ".go") {
+ return false;
+ }
+
+ // ignore test files unless explicitly included
+ return *allgo || !strings.HasSuffix(filename, "_test.go");
+}
+
+
+func getPackage(path string) (*ast.Package, os.Error) {
+ if len(path) == 0 {
+ return nil, os.NewError("no path specified");
+ }
+
+ if strings.HasSuffix(path, ".go") || path == "/dev/stdin" {
+ // single go file
+ src, err := parser.ParseFile(path, nil, parserMode());
+ if err != nil {
+ return nil, err;
+ }
+ dirname, filename := pathutil.Split(path);
+ return &ast.Package{src.Name.Value, dirname, map[string]*ast.File{filename: src}}, nil;
+ }
+
+ // len(path) > 0
+ switch ch := path[0]; {
+ case ch == '.':
+ // cwd-relative path
+ if cwd, err := os.Getwd(); err == nil {
+ path = pathutil.Join(cwd, path);
+ }
+ case ch != '/':
+ // goroot/pkgDir-relative path
+ path = pathutil.Join(pathutil.Join(*goroot, pkgDir), path);
+ }
+
+ return parser.ParsePackage(path, isPkgFile, parserMode());
+}
+
+
func printerMode() uint {
mode := printer.DocComments;
if *optcommas {
func main() {
+ flag.Usage = usage;
flag.Parse();
- var filename string;
+ path := "";
switch flag.NArg() {
- case 0: filename = "/dev/stdin";
- case 1: filename = flag.Arg(0);
- default: usage();
+ case 0:
+ path = "/dev/stdin";
+ case 1:
+ path = flag.Arg(0);
+ default:
+ usage();
}
- src, err := io.ReadFile(filename);
- if err != nil {
- fmt.Fprintf(os.Stderr, "%v\n", err);
- os.Exit(1);
- }
-
- prog, err := parser.Parse(filename, src, parserMode());
+ pkg, err := getPackage(path);
if err != nil {
scanner.PrintError(os.Stderr, err);
os.Exit(1);
}
if !*silent {
+ w := makeTabwriter(os.Stdout);
if *exports {
- ast.FilterExports(prog); // ignore result
+ src := ast.PackageInterface(pkg);
+ printer.Fprint(w, src, printerMode()); // ignore errors
+ } else {
+ for _, src := range pkg.Files {
+ printer.Fprint(w, src, printerMode()); // ignore errors
+ }
}
- w := makeTabwriter(os.Stdout);
- printer.Fprint(w, prog, printerMode()); // ignore errors
w.Flush();
}
}
fmt.install: io.install os.install reflect.install strconv.install utf8.install
go/ast.install: go/token.install unicode.install utf8.install
go/doc.install: container/vector.install fmt.install go/ast.install go/token.install io.install once.install regexp.install sort.install strings.install template.install
-go/parser.install: bytes.install container/vector.install fmt.install go/ast.install go/scanner.install go/token.install io.install os.install strings.install
+go/parser.install: bytes.install container/vector.install fmt.install go/ast.install go/scanner.install go/token.install io.install os.install path.install strings.install
go/printer.install: fmt.install go/ast.install go/token.install io.install os.install reflect.install strings.install
go/scanner.install: bytes.install container/vector.install fmt.install go/token.install io.install os.install sort.install strconv.install unicode.install utf8.install
go/token.install: strconv.install
flag\
fmt\
go/parser\
+ go/printer\
go/scanner\
gob\
hash/adler32\
// license that can be found in the LICENSE file.
// The AST package declares the types used to represent
-// syntax trees for Go source files.
+// syntax trees for Go packages.
//
package ast
// ----------------------------------------------------------------------------
-// Programs
+// Files and packages
-// A Program node represents the root node of an AST
-// for an entire source file.
+// A File node represents a Go source file.
//
-type Program struct {
+type File struct {
Doc *CommentGroup; // associated documentation; or nil
token.Position; // position of "package" keyword
Name *Ident; // package name
Decls []Decl; // top-level declarations
Comments []*CommentGroup; // list of unassociated comments
}
+
+
+// A Package node represents a set of source files
+// collectively building a Go package.
+//
+type Package struct {
+ Name string; // package name
+ Path string; // package path
+ Files map[string]*File; // path-relative filenames
+}
// FilterExports returns true if there is an exported declaration; it returns
// false otherwise.
//
-func FilterExports(prog *Program) bool {
+func FilterExports(src *File) bool {
j := 0;
- for _, d := range prog.Decls {
+ for _, d := range src.Decls {
if filterDecl(d) {
- prog.Decls[j] = d;
+ src.Decls[j] = d;
j++;
}
}
- prog.Decls = prog.Decls[0 : j];
+ src.Decls = src.Decls[0 : j];
return j > 0;
}
+
+
+// PackageInterface returns an AST containing only the exported declarations
+// of the package pkg. The pkg AST is modified by PackageInterface.
+//
+func PackageInterface(pkg *Package) *File {
+ // filter each package file
+ for filename, s := range pkg.Files {
+ if !FilterExports(s) {
+ pkg.Files[filename] = nil, false;
+ }
+ }
+
+ // compute total number of top-level declarations in all source files
+ var doc *CommentGroup;
+ n := 0;
+ for _, src := range pkg.Files {
+ if doc == nil && src.Doc != nil {
+ // TODO(gri) what to do with multiple package comments?
+ doc = src.Doc;
+ }
+ n += len(src.Decls);
+ }
+
+ // collect top-level declarations of all source files
+ decls := make([]Decl, n);
+ i := 0;
+ for _, src := range pkg.Files {
+ for _, d := range src.Decls {
+ decls[i] = d;
+ i++;
+ }
+ }
+
+ // TODO(gri) should also collect comments so that this function
+ // can be used by godoc.
+ var noPos token.Position;
+ return &File{doc, noPos, &Ident{noPos, pkg.Name}, decls, nil};
+}
)
-// AddProgram adds the AST for a source file to the DocReader.
+// AddFile adds the AST for a source file to the DocReader.
// Adding the same AST multiple times is a no-op.
//
-func (doc *DocReader) AddProgram(prog *ast.Program) {
+func (doc *DocReader) AddFile(src *ast.File) {
if bug_markers == nil {
bug_markers = makeRex("^/[/*][ \t]*BUG\\(.*\\):[ \t]*"); // BUG(uid):
bug_content = makeRex("[^ \n\r\t]+"); // at least one non-whitespace char
}
- if doc.name != prog.Name.Value {
+ if doc.name != src.Name.Value {
panic("package names don't match");
}
// add package documentation
// TODO(gri) what to do if there are multiple files?
- if prog.Doc != nil {
- doc.doc = prog.Doc
+ if src.Doc != nil {
+ doc.doc = src.Doc
}
// add all declarations
- for _, decl := range prog.Decls {
+ for _, decl := range src.Decls {
doc.addDecl(decl);
}
// collect BUG(...) comments
- for _, c := range prog.Comments {
+ for _, c := range src.Comments {
text := c.List[0].Text;
cstr := string(text);
if m := bug_markers.Execute(cstr); len(m) > 0 {
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE file.
+
# DO NOT EDIT. Automatically generated by gobuild.
-# gobuild -m >Makefile
+# gobuild -m parser.go interface.go >Makefile
D=/go/
coverage: packages
gotest
- 6cov -g `pwd` | grep -v '_test\.go:'
+ 6cov -g $$(pwd) | grep -v '_test\.go:'
%.$O: %.go
$(GC) -I_obj $*.go
O1=\
parser.$O\
+O2=\
+ interface.$O\
+
-phases: a1
+phases: a1 a2
_obj$D/parser.a: phases
a1: $(O1)
$(AR) grc _obj$D/parser.a parser.$O
rm -f $(O1)
+a2: $(O2)
+ $(AR) grc _obj$D/parser.a interface.$O
+ rm -f $(O2)
+
newpkg: clean
mkdir -p _obj$D
$(O1): newpkg
$(O2): a1
+$(O3): a2
nuke: clean
rm -f $(GOROOT)/pkg/$(GOOS)_$(GOARCH)$D/parser.a
--- /dev/null
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file contains the exported entry points for invoking the parser.
+
+package parser
+
+import (
+ "bytes";
+ "fmt";
+ "go/ast";
+ "go/parser";
+ "go/scanner";
+ "io";
+ "os";
+ pathutil "path";
+ "strings";
+)
+
+
+// If src != nil, readSource converts src to a []byte if possible;
+// otherwise it returns an error. If src == nil, readSource returns
+// the result of reading the file specified by filename.
+//
+func readSource(filename string, src interface{}) ([]byte, os.Error) {
+ if src != nil {
+ switch s := src.(type) {
+ case string:
+ return strings.Bytes(s), nil;
+ case []byte:
+ return s, nil;
+ case *bytes.Buffer:
+ // is io.Reader, but src is already available in []byte form
+ if s != nil {
+ return s.Data(), nil;
+ }
+ case io.Reader:
+ var buf bytes.Buffer;
+ n, err := io.Copy(s, &buf);
+ if err != nil {
+ return nil, err;
+ }
+ return buf.Data(), nil;
+ default:
+ return nil, os.ErrorString("invalid source");
+ }
+ }
+
+ return io.ReadFile(filename);
+}
+
+
+// ParseExpr parses a Go expression and returns the corresponding
+// AST node. The filename and src arguments have the same interpretation
+// as for ParseFile. If there is an error, the result expression
+// may be nil or contain a partial AST.
+//
+func ParseExpr(filename string, src interface{}) (ast.Expr, os.Error) {
+ data, err := readSource(filename, src);
+ if err != nil {
+ return nil, err;
+ }
+
+ var p parser;
+ p.init(filename, data, 0);
+ x := p.parseExpr(); // TODO 6g bug - function call order in expr lists
+ return x, p.GetError(scanner.Sorted);
+}
+
+
+// ParseStmtList parses a list of Go statements and returns the list
+// of corresponding AST nodes. The filename and src arguments have the same
+// interpretation as for ParseFile. If there is an error, the node
+// list may be nil or contain partial ASTs.
+//
+func ParseStmtList(filename string, src interface{}) ([]ast.Stmt, os.Error) {
+ data, err := readSource(filename, src);
+ if err != nil {
+ return nil, err;
+ }
+
+ var p parser;
+ p.init(filename, data, 0);
+ list := p.parseStmtList(); // TODO 6g bug - function call order in expr lists
+ return list, p.GetError(scanner.Sorted);
+}
+
+
+// ParseFile parses a Go source file and returns a File node.
+//
+// If src != nil, ParseFile parses the file source from src. src may
+// be provided in a variety of formats. At the moment the following types
+// are supported: string, []byte, and io.Reader. In this case, filename is
+// only used for source position information and error messages.
+//
+// If src == nil, ParseFile parses the file specified by filename.
+//
+// The mode parameter controls the amount of source text parsed and other
+// optional parser functionality.
+//
+// If the source couldn't be read, the returned AST is nil and the error
+// indicates the specific failure. If the source was read but syntax
+// errors were found, the result is a partial AST (with ast.BadX nodes
+// representing the fragments of erroneous source code). Multiple errors
+// are returned via a scanner.ErrorList which is sorted by file position.
+//
+func ParseFile(filename string, src interface{}, mode uint) (*ast.File, os.Error) {
+ data, err := readSource(filename, src);
+ if err != nil {
+ return nil, err;
+ }
+
+ var p parser;
+ p.init(filename, data, mode);
+ prog := p.parseFile(); // TODO 6g bug - function call order in expr lists
+ return prog, p.GetError(scanner.NoMultiples);
+}
+
+
+// ParsePkgFile parses the file specified by filename and returns the
+// corresponding AST. If the file cannot be read, has syntax errors, or
+// does not belong to the package (i.e., pkgname != "" and the package
+// name in the file doesn't match pkkname), an error is returned. Mode
+// flags that control the amount of source text parsed are ignored.
+//
+func ParsePkgFile(pkgname, filename string, mode uint) (*ast.File, os.Error) {
+ src, err := io.ReadFile(filename);
+ if err != nil {
+ return nil, err;
+ }
+
+ if pkgname != "" {
+ prog, err := ParseFile(filename, src, PackageClauseOnly);
+ if err != nil {
+ return nil, err;
+ }
+ if prog.Name.Value != pkgname {
+ return nil, os.NewError(fmt.Sprintf("multiple packages found: %s, %s", prog.Name.Value, pkgname));
+ }
+ }
+
+ // ignore flags that control partial parsing
+ return ParseFile(filename, src, mode &^ (PackageClauseOnly | ImportsOnly));
+}
+
+
+// ParsePackage parses all files in the directory specified by path and
+// returns an AST representing the package found. The set of files may be
+// restricted by providing a non-nil filter function; only the files with
+// (path-local) filenames passing through the filter are considered. If
+// zero or more then one package is found, an error is returned. Mode
+// flags that control the amount of source text parsed are ignored.
+//
+func ParsePackage(path string, filter func(string) bool, mode uint) (*ast.Package, os.Error) {
+ fd, err := os.Open(path, os.O_RDONLY, 0);
+ if err != nil {
+ return nil, err;
+ }
+
+ list, err := fd.Readdirnames(-1);
+ if err != nil {
+ return nil, err;
+ }
+
+ name := "";
+ files := make(map[string]*ast.File);
+ for _, filename := range list {
+ if filter == nil || filter(filename) {
+ src, err := ParsePkgFile(name, pathutil.Join(path, filename), mode);
+ if err != nil {
+ return nil, err;
+ }
+ files[filename] = src;
+ if name == "" {
+ name = src.Name.Value;
+ }
+ }
+ }
+
+ if len(files) == 0 {
+ return nil, os.NewError(path + ": no package found");
+ }
+
+ return &ast.Package{name, path, files}, nil;
+}
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// A parser for Go source text. The input is a stream of lexical tokens
-// provided via the Scanner interface. The output is an abstract syntax
-// tree (AST) representing the Go source. The parser is invoked by calling
-// Parse.
+// A parser for Go source files. Input may be provided in a variety of
+// forms (see the various Parse* functions); the output is an abstract
+// syntax tree (AST) representing the Go source. The parser is invoked
+// through one of the Parse* functions.
//
package parser
var noIndex = [2]int{-1, -1};
+// noPos is used when there is no corresponding source position for a token.
+var noPos token.Position;
+
+
+// The mode parameter to the Parse* functions is a set of flags (or 0).
+// They control the amount of source code parsed and other optional
+// parser functionality.
+//
+const (
+ PackageClauseOnly uint = 1 << iota; // parsing stops after package clause
+ ImportsOnly; // parsing stops after import declarations
+ ParseComments; // parse comments and add them to AST
+ Trace; // print a trace of parsed productions
+)
+
+
// The parser structure holds the parser's internal state.
type parser struct {
scanner.ErrorVector;
};
-// noPos is used when there is no corresponding source position for a token
-var noPos token.Position;
+// scannerMode returns the scanner mode bits given the parser's mode bits.
+func scannerMode(mode uint) uint {
+ if mode & ParseComments != 0 {
+ return scanner.ScanComments;
+ }
+ return 0;
+}
+
+
+func (p *parser) next()
+
+func (p *parser) init(filename string, src []byte, mode uint) {
+ p.ErrorVector.Init();
+ p.scanner.Init(filename, src, p, scannerMode(mode));
+ p.mode = mode;
+ p.trace = mode & Trace != 0; // for convenience (p.trace is used frequently)
+ p.comments.Init(0);
+ p.commentsIndex = noIndex;
+ p.next();
+}
// ----------------------------------------------------------------------------
func (p *parser) tryType() ast.Expr
func (p *parser) parseStringList(x *ast.StringLit) []*ast.StringLit
-func (p *parser) parseExpression() ast.Expr
-func (p *parser) parseStatement() ast.Stmt
-func (p *parser) parseDeclaration(getSemi bool) (decl ast.Decl, gotSemi bool)
+func (p *parser) parseExpr() ast.Expr
+func (p *parser) parseStmt() ast.Stmt
+func (p *parser) parseDecl(getSemi bool) (decl ast.Decl, gotSemi bool)
func (p *parser) parseIdent() *ast.Ident {
}
-func (p *parser) parseExpressionList() []ast.Expr {
+func (p *parser) parseExprList() []ast.Expr {
if p.trace {
defer un(trace(p, "ExpressionList"));
}
list := vector.New(0);
- list.Push(p.parseExpression());
+ list.Push(p.parseExpr());
for p.tok == token.COMMA {
p.next();
- list.Push(p.parseExpression());
+ list.Push(p.parseExpr());
}
// convert list
len = &ast.Ellipsis{p.pos};
p.next();
} else if p.tok != token.RBRACK {
- len = p.parseExpression();
+ len = p.parseExpr();
}
p.expect(token.RBRACK);
elt := p.parseType();
}
-func (p *parser) parseStatementList() []ast.Stmt {
+func (p *parser) parseStmtList() []ast.Stmt {
if p.trace {
defer un(trace(p, "StatementList"));
}
p.expect(token.SEMICOLON);
expectSemi = false;
}
- list.Push(p.parseStatement());
+ list.Push(p.parseStmt());
if p.tok == token.SEMICOLON {
p.next();
} else if p.optSemi {
}
lbrace := p.expect(token.LBRACE);
- list := p.parseStatementList();
+ list := p.parseStmtList();
rbrace := p.expect(token.RBRACE);
p.optSemi = true;
lparen := p.pos;
p.next();
p.exprLev++;
- x := p.parseExpression();
+ x := p.parseExpr();
p.exprLev--;
rparen := p.expect(token.RPAREN);
return &ast.ParenExpr{lparen, x, rparen};
p.expect(token.LBRACK);
p.exprLev++;
- begin := p.parseExpression();
+ begin := p.parseExpr();
var end ast.Expr;
if p.tok == token.COLON {
p.next();
- end = p.parseExpression();
+ end = p.parseExpr();
}
p.exprLev--;
p.expect(token.RBRACK);
lparen := p.expect(token.LPAREN);
var args []ast.Expr;
if p.tok != token.RPAREN {
- args = p.parseExpressionList();
+ args = p.parseExprList();
}
rparen := p.expect(token.RPAREN);
defer un(trace(p, "Element"));
}
- x := p.parseExpression();
+ x := p.parseExpr();
if p.tok == token.COLON {
colon := p.pos;
p.next();
- x = &ast.KeyValueExpr{x, colon, p.parseExpression()};
+ x = &ast.KeyValueExpr{x, colon, p.parseExpr()};
}
return x;
}
-func (p *parser) parseExpression() ast.Expr {
+func (p *parser) parseExpr() ast.Expr {
if p.trace {
defer un(trace(p, "Expression"));
}
defer un(trace(p, "SimpleStmt"));
}
- x := p.parseExpressionList();
+ x := p.parseExprList();
switch p.tok {
case token.COLON:
p.next();
if labelOk && len(x) == 1 {
if label, isIdent := x[0].(*ast.Ident); isIdent {
- return &ast.LabeledStmt{label, p.parseStatement()};
+ return &ast.LabeledStmt{label, p.parseStmt()};
}
}
p.Error(x[0].Pos(), "illegal label declaration");
// assignment statement
pos, tok := p.pos, p.tok;
p.next();
- y := p.parseExpressionList();
+ y := p.parseExprList();
if len(x) > 1 && len(y) > 1 && len(x) != len(y) {
p.Error(x[0].Pos(), "arity of lhs doesn't match rhs");
}
func (p *parser) parseCallExpr() *ast.CallExpr {
- x := p.parseExpression();
+ x := p.parseExpr();
if call, isCall := x.(*ast.CallExpr); isCall {
return call;
}
p.expect(token.RETURN);
var x []ast.Expr;
if p.tok != token.SEMICOLON && p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE {
- x = p.parseExpressionList();
+ x = p.parseExprList();
}
return &ast.ReturnStmt{pos, x};
var else_ ast.Stmt;
if p.tok == token.ELSE {
p.next();
- else_ = p.parseStatement();
+ else_ = p.parseStmt();
}
return &ast.IfStmt{pos, s1, p.makeExpr(s2), body, else_};
var x []ast.Expr;
if p.tok == token.CASE {
p.next();
- x = p.parseExpressionList();
+ x = p.parseExprList();
} else {
p.expect(token.DEFAULT);
}
colon := p.expect(token.COLON);
- body := p.parseStatementList();
+ body := p.parseStmtList();
return &ast.CaseClause{pos, x, colon, body};
}
}
colon := p.expect(token.COLON);
- body := p.parseStatementList();
+ body := p.parseStmtList();
return &ast.TypeCaseClause{pos, typ, colon, body};
}
p.next();
if p.tok == token.ARROW {
// RecvExpr without assignment
- rhs = p.parseExpression();
+ rhs = p.parseExpr();
} else {
// SendExpr or RecvExpr
- rhs = p.parseExpression();
+ rhs = p.parseExpr();
if p.tok == token.ASSIGN || p.tok == token.DEFINE {
// RecvExpr with assignment
tok = p.tok;
p.next();
lhs = rhs;
if p.tok == token.ARROW {
- rhs = p.parseExpression();
+ rhs = p.parseExpr();
} else {
p.expect(token.ARROW); // use expect() error handling
}
}
colon := p.expect(token.COLON);
- body := p.parseStatementList();
+ body := p.parseStmtList();
return &ast.CommClause{pos, tok, lhs, rhs, colon, body};
}
}
-func (p *parser) parseStatement() ast.Stmt {
+func (p *parser) parseStmt() ast.Stmt {
if p.trace {
defer un(trace(p, "Statement"));
}
switch p.tok {
case token.CONST, token.TYPE, token.VAR:
- decl, _ := p.parseDeclaration(false); // do not consume trailing semicolon
+ decl, _ := p.parseDecl(false); // do not consume trailing semicolon
return &ast.DeclStmt{decl};
case
// tokens that may start a top-level expression
var values []ast.Expr;
if typ != nil || p.tok == token.ASSIGN {
p.expect(token.ASSIGN);
- values = p.parseExpressionList();
+ values = p.parseExprList();
}
comment, gotSemi := p.parseComment(getSemi);
var values []ast.Expr;
if typ == nil || p.tok == token.ASSIGN {
p.expect(token.ASSIGN);
- values = p.parseExpressionList();
+ values = p.parseExprList();
}
comment, gotSemi := p.parseComment(getSemi);
}
-func (p *parser) parseDeclaration(getSemi bool) (decl ast.Decl, gotSemi bool) {
+func (p *parser) parseDecl(getSemi bool) (decl ast.Decl, gotSemi bool) {
if p.trace {
defer un(trace(p, "Declaration"));
}
// ----------------------------------------------------------------------------
-// Packages
+// Source files
-// The mode parameter to the Parse function is a set of flags (or 0).
-// They control the amount of source code parsed and other optional
-// parser functionality.
-//
-const (
- PackageClauseOnly uint = 1 << iota; // parsing stops after package clause
- ImportsOnly; // parsing stops after import declarations
- ParseComments; // parse comments and add them to AST
- Trace; // print a trace of parsed productions
-)
-
-
-func (p *parser) parsePackage() *ast.Program {
+func (p *parser) parseFile() *ast.File {
if p.trace {
- defer un(trace(p, "Program"));
+ defer un(trace(p, "File"));
}
// package clause
if p.mode & ImportsOnly == 0 {
// rest of package body
for p.tok != token.EOF {
- decl, _ := p.parseDeclaration(true); // consume optional semicolon
+ decl, _ := p.parseDecl(true); // consume optional semicolon
list.Push(decl);
}
}
}
}
- return &ast.Program{comment, pos, ident, decls, comments};
-}
-
-
-// ----------------------------------------------------------------------------
-// Parser entry points.
-
-func readSource(src interface{}) ([]byte, os.Error) {
- if src != nil {
- switch s := src.(type) {
- case string:
- return strings.Bytes(s), nil;
- case []byte:
- return s, nil;
- case *bytes.Buffer:
- // is io.Reader, but src is already available in []byte form
- if s != nil {
- return s.Data(), nil;
- }
- case io.Reader:
- var buf bytes.Buffer;
- n, err := io.Copy(s, &buf);
- if err != nil {
- return nil, err;
- }
- return buf.Data(), nil;
- }
- }
- return nil, os.ErrorString("invalid source");
-}
-
-
-// scannerMode returns the scanner mode bits given the parser's mode bits.
-func scannerMode(mode uint) uint {
- if mode & ParseComments != 0 {
- return scanner.ScanComments;
- }
- return 0;
-}
-
-
-func (p *parser) init(filename string, src interface{}, mode uint) os.Error {
- data, err := readSource(src);
- if err != nil {
- return err;
- }
-
- // initialize parser state
- p.ErrorVector.Init();
- p.scanner.Init(filename, data, p, scannerMode(mode));
- p.mode = mode;
- p.trace = mode & Trace != 0; // for convenience (p.trace is used frequently)
- p.comments.Init(0);
- p.commentsIndex = noIndex;
- p.next();
-
- return nil;
-}
-
-
-// Parse parses a Go program.
-//
-// The filename is only used in AST position information and error messages
-// and may be empty. The program source src may be provided in a variety of
-// formats. At the moment the following types are supported: string, []byte,
-// and io.Reader. The mode parameter controls the amount of source text parsed
-// and other optional parser functionality.
-//
-// Parse returns a complete AST if no error occured. Otherwise, if the
-// source couldn't be read, the returned program is nil and the error
-// indicates the specific failure. If the source was read but syntax
-// errors were found, the result is a partial AST (with ast.BadX nodes
-// representing the fragments of erroneous source code). Multiple errors
-// are returned via a scanner.ErrorList which is sorted by file position.
-//
-func Parse(filename string, src interface{}, mode uint) (*ast.Program, os.Error) {
- var p parser;
- if err := p.init(filename, src, mode); err != nil {
- return nil, err;
- }
-
- prog := p.parsePackage(); // TODO 6g bug - function call order in expr lists
- return prog, p.GetError(scanner.NoMultiples);
-}
-
-
-// ParseStmts parses a list of Go statements and returns the list of
-// corresponding AST nodes. The filename and src arguments have the
-// same interpretation as for Parse. If there is an error, the node
-// list may be nil or contain partial ASTs.
-//
-func ParseStmts(filename string, src interface{}) ([]ast.Stmt, os.Error) {
- var p parser;
- if err := p.init(filename, src, 0); err != nil {
- return nil, err;
- }
-
- list := p.parseStatementList(); // TODO 6g bug - function call order in expr lists
- return list, p.GetError(scanner.Sorted);
-}
-
-
-// ParseExpr parses a single Go expression and returns the corresponding
-// AST node. The filename and src arguments have the same interpretation
-// as for Parse. If there is an error, the result expression may be nil
-// or contain a partial AST.
-//
-func ParseExpr(filename string, src interface{}) (ast.Expr, os.Error) {
- var p parser;
- if err := p.init(filename, src, 0); err != nil {
- return nil, err;
- }
-
- x := p.parseExpression(); // TODO 6g bug - function call order in expr lists
- return x, p.GetError(scanner.Sorted);
+ return &ast.File{comment, pos, ident, decls, comments};
}
func TestParseIllegalInputs(t *testing.T) {
for _, src := range illegalInputs {
- prog, err := Parse("", src, 0);
+ prog, err := ParseFile("", src, 0);
if err == nil {
- t.Errorf("Parse(%v) should have failed", src);
+ t.Errorf("ParseFile(%v) should have failed", src);
}
}
}
func TestParseValidPrograms(t *testing.T) {
for _, src := range validPrograms {
- prog, err := Parse("", src, 0);
+ prog, err := ParseFile("", src, 0);
if err != nil {
- t.Errorf("Parse(%q) failed: %v", src, err);
+ t.Errorf("ParseFile(%q): %v", src, err);
}
}
}
func TestParse3(t *testing.T) {
for _, filename := range validFiles {
- src, err := os.Open(filename, os.O_RDONLY, 0);
- defer src.Close();
+ prog, err := ParseFile(filename, nil, 0);
if err != nil {
- t.Fatal(err);
+ t.Errorf("ParseFile(%s): %v", filename, err);
}
+ }
+}
- prog, err := Parse(filename, src, 0);
- if err != nil {
- t.Errorf("Parse(%s): %v", filename, err);
+
+func filter(filename string) bool {
+ switch filename {
+ case "parser.go":
+ case "interface.go":
+ case "parser_test.go":
+ default:
+ return false;
+ }
+ return true;
+}
+
+
+func TestParse4(t *testing.T) {
+ path := ".";
+ pkg, err := ParsePackage(path, filter, 0);
+ if err != nil {
+ t.Errorf("ParsePackage(%s): %v", path, err);
+ }
+ if pkg.Name != "parser" {
+ t.Errorf("incorrect package name: %s", pkg.Name);
+ }
+ for filename, _ := range pkg.Files {
+ if !filter(filename) {
+ t.Errorf("unexpected package file: %s", filename);
}
}
}
// ----------------------------------------------------------------------------
-// Programs
+// Files
-func (p *printer) program(prog *ast.Program) {
- p.setComments(prog.Comments); // unassociated comments
+func (p *printer) file(src *ast.File) {
+ p.setComments(src.Comments); // unassociated comments
- p.leadingComment(prog.Doc);
- p.print(prog.Pos(), token.PACKAGE, blank);
- p.expr(prog.Name);
+ p.leadingComment(src.Doc);
+ p.print(src.Pos(), token.PACKAGE, blank);
+ p.expr(src.Name);
- for _, d := range prog.Decls {
+ for _, d := range src.Decls {
p.print(newline, newline);
comment, _ := p.decl(d);
if p.optSemis() {
// Public interface
// Fprint "pretty-prints" an AST node to output and returns the number of
-// bytes written, and an error, if any. The node type must be *ast.Program,
+// bytes written, and an error, if any. The node type must be *ast.File,
// or assignment-compatible to ast.Expr, ast.Decl, or ast.Stmt. Printing is
// controlled by the mode parameter. For best results, the output should be
// a tabwriter.Writer.
case ast.Decl:
comment, _ := p.decl(n);
p.trailingComment(comment); // no newline at end
- case *ast.Program:
- p.program(n);
+ case *ast.File:
+ p.file(n);
default:
p.errors <- os.NewError("unsupported node type");
}
func check(t *testing.T, source, golden string, exports bool) {
- // get source
- src, err := io.ReadFile(source);
- if err != nil {
- t.Error(err);
- return;
- }
-
// parse source
- prog, err := parser.Parse(src, parser.ParseComments);
+ prog, err := parser.ParseFile(source, nil, parser.ParseComments);
if err != nil {
t.Error(err);
return;