- func ParseDir(fset *token.FileSet, path string, filter func(os.FileInfo) bool, mode Mode) (pkgs map[string]*ast.Package, first error)
- func ParseExpr(x string) (ast.Expr, error)
- func ParseFile(fset *token.FileSet, filename string, src interface{}, mode Mode) (*ast.File, error)
- type Mode
Examples
- ParseFile
Package files
interface.go
parser.go
func ParseDir(fset *token.FileSet, path string, filter func(os.FileInfo) bool, mode Mode) (pkgs map[string]*ast.Package, first error)
ParseDir calls ParseFile for the files in the directory specified by path and
returns a map of package name -> package AST with all the packages found. If
filter != nil, only the files with os.FileInfo entries passing through the filter
are considered. The mode bits are passed to ParseFile unchanged. Position
information is recorded in the file set fset.
If the directory couldn't be read, a nil map and the respective error are
returned. If a parse error occurred, a non-nil but incomplete map and the
first error encountered are returned.
func ParseExpr(x string) (ast.Expr, error)
ParseExpr is a convenience function for obtaining the AST of an expression x.
The position information recorded in the AST is undefined.
func ParseFile(fset *token.FileSet, filename string, src interface{}, mode Mode) (*ast.File, error)
ParseFile parses the source code of a single Go source file and returns
the corresponding ast.File node. The source code may be provided via
the filename of the source file, or via the src parameter.
If src != nil, ParseFile parses the source from src and the filename is
only used when recording position information. The type of the argument
for the src parameter must be string, []byte, or io.Reader.
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. Position information is recorded in the
file set fset.
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.Bad* nodes
representing the fragments of erroneous source code). Multiple errors
are returned via a scanner.ErrorList which is sorted by file position.
? Example
Code:
fset := token.NewFileSet() // positions are relative to fset
// Parse the file containing this very example
// but stop after processing the imports.
f, err := parser.ParseFile(fset, "example_test.go", nil, parser.ImportsOnly)
if err != nil {
fmt.Println(err)
return
}
// Print the imports from the file's AST.
for _, s := range f.Imports {
fmt.Println(s.Path.Value)
}
Output:
"fmt"
"go/parser"
"go/token"
type Mode uint
A Mode value is a set of flags (or 0).
They control the amount of source code parsed and other optional
parser functionality.
const (
PackageClauseOnly Mode = 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
DeclarationErrors // report declaration errors
SpuriousErrors // report all (not just the first) errors per line
)