func openProg(name string, p *Prog) {
var err os.Error
- p.AST, err = parser.ParseFile(name, nil, parser.ParseComments)
+ p.AST, err = parser.ParseFile(name, nil, nil, parser.ParseComments)
if err != nil {
if list, ok := err.(scanner.ErrorList); ok {
// If err is a scanner.ErrorList, its String will print just
for _, c := range p.Crefs {
// If we've already found this name as a define, it is not a Cref.
if val, ok := defines[c.Name]; ok {
- _, err := parser.ParseExpr("", val)
+ _, err := parser.ParseExpr("", val, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "The value in C.%s does not parse as a Go expression; cannot use.\n", c.Name)
os.Exit(2)
func pkgName(filename string) string {
- file, err := parser.ParseFile(filename, nil, parser.PackageClauseOnly)
+ file, err := parser.ParseFile(filename, nil, nil, parser.PackageClauseOnly)
if err != nil || file == nil {
return ""
}
nfiles++
if text == "" {
// no package documentation yet; take the first found
- file, err := parser.ParseFile(pathutil.Join(path, d.Name), nil,
+ file, err := parser.ParseFile(pathutil.Join(path, d.Name), nil, nil,
parser.ParseComments|parser.PackageClauseOnly)
if err == nil &&
// Also accept fakePkgName, so we get synopses for commmands.
Error string
}
- file, err := parser.ParseFile(path, nil, parser.ParseComments)
+ file, err := parser.ParseFile(path, nil, nil, parser.ParseComments)
info.Source = StyledNode{file, &Styler{linetags: true, highlight: r.FormValue("h")}}
if err != nil {
info.Error = err.String()
return
}
- file, err := parser.ParseFile(path, nil, parser.ParseComments)
+ file, err := parser.ParseFile(path, nil, nil, parser.ParseComments)
if err != nil {
return // ignore files with (parse) errors
}
rewriteRule = flag.String("r", "", "rewrite rule (e.g., 'α[β:len(α)] -> α[β:]')")
// debugging support
- checks = flag.Bool("checks", false, "do semantic checks")
comments = flag.Bool("comments", true, "print comments")
+ debug = flag.Bool("debug", false, "print debugging information")
trace = flag.Bool("trace", false, "print parse trace")
// layout control
func initParserMode() {
parserMode = uint(0)
- if *checks {
- parserMode |= parser.CheckSemantics
- }
if *comments {
parserMode |= parser.ParseComments
}
if *useOldParser {
file, err = oldParser.ParseFile(f.Name(), src, parserMode)
} else {
- file, err = parser.ParseFile(f.Name(), src, parserMode)
+ var scope *ast.Scope
+ if *debug {
+ scope = ast.NewScope(nil)
+ }
+ file, err = parser.ParseFile(f.Name(), src, scope, parserMode)
}
if err != nil {
return err
// but there are problems with preserving formatting and also
// with what a wildcard for a statement looks like.
func parseExpr(s string, what string) ast.Expr {
- x, err := parser.ParseExpr("input", s)
+ x, err := parser.ParseExpr("input", s, nil)
if err != nil {
fmt.Fprintf(os.Stderr, "parsing %s %s: %s\n", what, s, err)
os.Exit(2)
return nil, os.NewError(path + ": no package found")
}
- return &ast.Package{name, path, files}, nil
+ return &ast.Package{name, path, nil, files}, nil
}
type Package struct {
Name string // package name
Path string // package path
+ Scope *Scope // package scope
Files map[string]*File // path-relative filenames
}
// constant, type, variable, or function (incl. methods).
//
type Object struct {
- Kind ObjKind
- Pos token.Position // declaration position
- Name string // declared name
- Scope *Scope // scope in which the Object is declared
+ Kind ObjKind
+ Pos token.Position // declaration position
+ Name string // declared name
}
func NewObj(kind ObjKind, pos token.Position, name string) *Object {
- return &Object{kind, pos, name, nil}
+ return &Object{kind, pos, name}
}
// Declare attempts to insert a named object into the scope s.
// If the scope does not contain an object with that name yet,
-// Declare inserts the object, and the result is true. Otherwise,
-// the scope remains unchanged and the result is false.
-func (s *Scope) Declare(obj *Object) bool {
- if obj.Name != "_" {
- if _, found := s.Objects[obj.Name]; found {
- return false
- }
+// Declare inserts the object, and returns it. Otherwise, the
+// scope remains unchanged and Declare returns the object found
+// in the scope instead.
+func (s *Scope) Declare(obj *Object) *Object {
+ decl, found := s.Objects[obj.Name]
+ if !found {
s.Objects[obj.Name] = obj
+ decl = obj
}
- return true
+ return decl
}
"bytes"
"go/ast"
"go/scanner"
+ "go/token"
"io"
"io/ioutil"
"os"
}
-// TODO(gri) Simplify parser interface by splitting these functions
-// into two parts: a single Init and a respective xParse
-// function. The Init function can be shared.
-//
-// - the Init function will take a scope
-// - if a scope is provided, the parser tracks declarations, otherwise it won't
+func (p *parser) parseEOF() os.Error {
+ p.expect(token.EOF)
+ return p.GetError(scanner.Sorted)
+}
// ParseExpr parses a Go expression and returns the corresponding
-// AST node. The filename and src arguments have the same interpretation
+// AST node. The filename, src, and scope 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) {
+func ParseExpr(filename string, src interface{}, scope *ast.Scope) (ast.Expr, os.Error) {
data, err := readSource(filename, src)
if err != nil {
return nil, err
}
var p parser
- p.init(filename, data, nil, 0)
- return p.parseExpr(), p.GetError(scanner.Sorted)
+ p.init(filename, data, scope, 0)
+ return p.parseExpr(), p.parseEOF()
}
// ParseStmtList parses a list of Go statements and returns the list
-// of corresponding AST nodes. The filename and src arguments have the same
+// of corresponding AST nodes. The filename, src, and scope 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) {
+func ParseStmtList(filename string, src interface{}, scope *ast.Scope) ([]ast.Stmt, os.Error) {
data, err := readSource(filename, src)
if err != nil {
return nil, err
}
var p parser
- p.init(filename, data, nil, 0)
- return p.parseStmtList(), p.GetError(scanner.Sorted)
+ p.init(filename, data, scope, 0)
+ return p.parseStmtList(), p.parseEOF()
}
// ParseDeclList parses a list of Go declarations and returns the list
-// of corresponding AST nodes. The filename and src arguments have the same
+// of corresponding AST nodes. The filename, src, and scope arguments have the same
// interpretation as for ParseFile. If there is an error, the node
// list may be nil or contain partial ASTs.
//
-func ParseDeclList(filename string, src interface{}) ([]ast.Decl, os.Error) {
+func ParseDeclList(filename string, src interface{}, scope *ast.Scope) ([]ast.Decl, os.Error) {
data, err := readSource(filename, src)
if err != nil {
return nil, err
}
var p parser
- p.init(filename, data, nil, 0)
- return p.parseDeclList(), p.GetError(scanner.Sorted)
+ p.init(filename, data, scope, 0)
+ return p.parseDeclList(), p.parseEOF()
}
//
// If src == nil, ParseFile parses the file specified by filename.
//
+// If scope != nil, it is the immediately surrounding scope for the file
+// (the package scope) and it is used to lookup and declare identifiers.
+// When parsing multiple files belonging to a package, the same scope should
+// be provided to all files.
+//
// The mode parameter controls the amount of source text parsed and other
// optional parser functionality.
//
// 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) {
+func ParseFile(filename string, src interface{}, scope *ast.Scope, mode uint) (*ast.File, os.Error) {
data, err := readSource(filename, src)
if err != nil {
return nil, err
}
var p parser
- // TODO(gri) Remove CheckSemantics flag and code below once
- // scope is provided via Init.
- var scope *ast.Scope
- if mode&CheckSemantics != 0 {
- scope = ast.NewScope(nil)
- }
p.init(filename, data, scope, mode)
- return p.parseFile(), p.GetError(scanner.NoMultiples)
+ return p.parseFile(), p.GetError(scanner.NoMultiples) // parseFile() reads to EOF
}
return nil, err
}
+ scope := ast.NewScope(nil)
pkgs := make(map[string]*ast.Package)
for i := 0; i < len(list); i++ {
entry := &list[i]
if filter == nil || filter(entry) {
- src, err := ParseFile(pathutil.Join(path, entry.Name), nil, mode)
+ src, err := ParseFile(pathutil.Join(path, entry.Name), nil, scope, mode)
if err != nil {
return pkgs, err
}
name := src.Name.Name()
pkg, found := pkgs[name]
if !found {
- pkg = &ast.Package{name, path, make(map[string]*ast.File)}
+ pkg = &ast.Package{name, path, scope, make(map[string]*ast.File)}
pkgs[name] = pkg
}
pkg.Files[entry.Name] = src
PackageClauseOnly uint = 1 << iota // parsing stops after package clause
ImportsOnly // parsing stops after import declarations
ParseComments // parse comments and add them to AST
- CheckSemantics // do semantic checks (only declarations for now)
Trace // print a trace of parsed productions
)
func (p *parser) declIdent(scope *ast.Scope, id *ast.Ident) {
- ok := scope.Declare(id.Obj)
- if p.checkDecl && !ok {
- p.Error(id.Pos(), "'"+id.Name()+"' declared already")
+ decl := scope.Declare(id.Obj)
+ if p.checkDecl && decl != id.Obj {
+ if decl.Kind == ast.Err {
+ // declared object is a forward declaration - update it
+ *decl = *id.Obj
+ id.Obj = decl
+ return
+ }
+ p.Error(id.Pos(), "'"+id.Name()+"' declared already at "+decl.Pos.String())
}
}
p.expect(token.IDENT) // use expect() error handling
}
if obj == nil {
- // TODO(gri) These identifiers need to be tracked as
- // unresolved identifiers in the package
- // scope so that they can be resolved later.
+ // No declaration found: either we are outside any function
+ // (p.funcScope == nil) or the identifier is not declared
+ // in any function. Try the file and package scope.
+ obj = p.fileScope.Lookup(name) // file scope is nested in package scope
+ if obj == nil {
+ // No declaration found anywhere: track as
+ // unresolved identifier in the package scope.
+ obj = ast.NewObj(ast.Err, pos, name)
+ p.pkgScope.Declare(obj)
+ }
+ }
+ return &ast.Ident{pos, obj}
+}
+
+
+func (p *parser) findIdentInScope(scope *ast.Scope) *ast.Ident {
+ pos := p.pos
+ name := "_"
+ var obj *ast.Object
+ if p.tok == token.IDENT {
+ name = string(p.lit)
+ obj = scope.Lookup(name)
+ p.next()
+ } else {
+ p.expect(token.IDENT) // use expect() error handling
+ }
+ if obj == nil {
+ // TODO(gri) At the moment we always arrive here because
+ // we don't track the lookup scope (and sometimes
+ // we can't). Just create a useable ident for now.
obj = ast.NewObj(ast.Err, pos, name)
}
return &ast.Ident{pos, obj}
if p.tok == token.PERIOD {
// first identifier is a package identifier
p.next()
- sel := p.findIdent()
+ sel := p.findIdentInScope(nil)
x = &ast.SelectorExpr{x, sel}
}
return x
p.expect(token.PERIOD)
if p.tok == token.IDENT {
// selector
- sel := p.findIdent()
+ sel := p.findIdentInScope(nil)
return &ast.SelectorExpr{x, sel}
}
s := &ast.BranchStmt{p.pos, tok, nil}
p.expect(tok)
if tok != token.FALLTHROUGH && p.tok == token.IDENT {
- s.Label = p.findIdent()
+ s.Label = p.findIdentInScope(nil)
}
p.expectSemi()
}
-func (p *parser) parseFunctionDecl() *ast.FuncDecl {
+func (p *parser) parseFuncDecl() *ast.FuncDecl {
if p.trace {
defer un(trace(p, "FunctionDecl"))
}
f = parseVarSpec
case token.FUNC:
- return p.parseFunctionDecl()
+ return p.parseFuncDecl()
default:
pos := p.pos
package parser
import (
+ "go/ast"
"os"
"testing"
)
func TestParseIllegalInputs(t *testing.T) {
for _, src := range illegalInputs {
- _, err := ParseFile("", src, 0)
+ _, err := ParseFile("", src, nil, 0)
if err == nil {
t.Errorf("ParseFile(%v) should have failed", src)
}
func TestParseValidPrograms(t *testing.T) {
for _, src := range validPrograms {
- _, err := ParseFile("", src, 0)
+ _, err := ParseFile("", src, ast.NewScope(nil), 0)
if err != nil {
t.Errorf("ParseFile(%q): %v", src, err)
}
func TestParse3(t *testing.T) {
for _, filename := range validFiles {
- _, err := ParseFile(filename, nil, 0)
+ _, err := ParseFile(filename, nil, ast.NewScope(nil), 0)
if err != nil {
t.Errorf("ParseFile(%s): %v", filename, err)
}
if mode&oldSyntax != 0 {
prog, err = oldParser.ParseFile(source, nil, parser.ParseComments)
} else {
- prog, err = parser.ParseFile(source, nil, parser.ParseComments)
+ prog, err = parser.ParseFile(source, nil, nil, parser.ParseComments)
}
if err != nil {
t.Error(err)