1 // Copyright 2009 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
5 // This file contains the exported entry points for invoking the parser.
21 // If src != nil, readSource converts src to a []byte if possible;
22 // otherwise it returns an error. If src == nil, readSource returns
23 // the result of reading the file specified by filename.
25 func readSource(filename
string, src
interface{}) ([]byte, error
) {
27 switch s
:= src
.(type) {
33 // is io.Reader, but src is already available in []byte form
39 if _
, err
:= io
.Copy(&buf
, s
); err
!= nil {
42 return buf
.Bytes(), nil
44 return nil, errors
.New("invalid source")
46 return ioutil
.ReadFile(filename
)
49 // A Mode value is a set of flags (or 0).
50 // They control the amount of source code parsed and other optional
51 // parser functionality.
56 PackageClauseOnly Mode
= 1 << iota // stop parsing after package clause
57 ImportsOnly
// stop parsing after import declarations
58 ParseComments
// parse comments and add them to AST
59 Trace
// print a trace of parsed productions
60 DeclarationErrors
// report declaration errors
61 SpuriousErrors
// same as AllErrors, for backward-compatibility
62 AllErrors
= SpuriousErrors
// report all errors (not just the first 10 on different lines)
65 // ParseFile parses the source code of a single Go source file and returns
66 // the corresponding ast.File node. The source code may be provided via
67 // the filename of the source file, or via the src parameter.
69 // If src != nil, ParseFile parses the source from src and the filename is
70 // only used when recording position information. The type of the argument
71 // for the src parameter must be string, []byte, or io.Reader.
72 // If src == nil, ParseFile parses the file specified by filename.
74 // The mode parameter controls the amount of source text parsed and other
75 // optional parser functionality. Position information is recorded in the
78 // If the source couldn't be read, the returned AST is nil and the error
79 // indicates the specific failure. If the source was read but syntax
80 // errors were found, the result is a partial AST (with ast.Bad* nodes
81 // representing the fragments of erroneous source code). Multiple errors
82 // are returned via a scanner.ErrorList which is sorted by file position.
84 func ParseFile(fset
*token
.FileSet
, filename
string, src
interface{}, mode Mode
) (f
*ast
.File
, err error
) {
86 text
, err
:= readSource(filename
, src
)
93 if e
:= recover(); e
!= nil {
94 _
= e
.(bailout
) // re-panics if it's not a bailout
99 // source is not a valid Go source file - satisfy
100 // ParseFile API and return a valid (but) empty
103 Name
: new(ast
.Ident
),
104 Scope
: ast
.NewScope(nil),
113 p
.init(fset
, filename
, text
, mode
)
119 // ParseDir calls ParseFile for all files with names ending in ".go" in the
120 // directory specified by path and returns a map of package name -> package
121 // AST with all the packages found.
123 // If filter != nil, only the files with os.FileInfo entries passing through
124 // the filter (and ending in ".go") are considered. The mode bits are passed
125 // to ParseFile unchanged. Position information is recorded in fset.
127 // If the directory couldn't be read, a nil map and the respective error are
128 // returned. If a parse error occurred, a non-nil but incomplete map and the
129 // first error encountered are returned.
131 func ParseDir(fset
*token
.FileSet
, path
string, filter
func(os
.FileInfo
) bool, mode Mode
) (pkgs
map[string]*ast
.Package
, first error
) {
132 fd
, err
:= os
.Open(path
)
138 list
, err
:= fd
.Readdir(-1)
143 pkgs
= make(map[string]*ast
.Package
)
144 for _
, d
:= range list
{
145 if strings
.HasSuffix(d
.Name(), ".go") && (filter
== nil ||
filter(d
)) {
146 filename
:= filepath
.Join(path
, d
.Name())
147 if src
, err
:= ParseFile(fset
, filename
, nil, mode
); err
== nil {
148 name
:= src
.Name
.Name
149 pkg
, found
:= pkgs
[name
]
153 Files
: make(map[string]*ast
.File
),
157 pkg
.Files
[filename
] = src
158 } else if first
== nil {
167 // ParseExpr is a convenience function for obtaining the AST of an expression x.
168 // The position information recorded in the AST is undefined. The filename used
169 // in error messages is the empty string.
171 func ParseExpr(x
string) (ast
.Expr
, error
) {
173 p
.init(token
.NewFileSet(), "", []byte(x
), 0)
175 // Set up pkg-level scopes to avoid nil-pointer errors.
176 // This is not needed for a correct expression x as the
177 // parser will be ok with a nil topScope, but be cautious
178 // in case of an erroneous x.
180 p
.pkgScope
= p
.topScope
181 e
:= p
.parseRhsOrType()
183 assert(p
.topScope
== nil, "unbalanced scopes")
185 // If a semicolon was inserted, consume it;
186 // report an error if there's more tokens.
187 if p
.tok
== token
.SEMICOLON
{
192 if p
.errors
.Len() > 0 {
194 return nil, p
.errors
.Err()