Source file
src/go/parser/interface.go
1
2
3
4
5
6
7 package parser
8
9 import (
10 "bytes"
11 "errors"
12 "go/ast"
13 "go/token"
14 "io"
15 "io/ioutil"
16 "os"
17 "path/filepath"
18 "strings"
19 )
20
21
22
23
24
25 func readSource(filename string, src interface{}) ([]byte, error) {
26 if src != nil {
27 switch s := src.(type) {
28 case string:
29 return []byte(s), nil
30 case []byte:
31 return s, nil
32 case *bytes.Buffer:
33
34 if s != nil {
35 return s.Bytes(), nil
36 }
37 case io.Reader:
38 var buf bytes.Buffer
39 if _, err := io.Copy(&buf, s); err != nil {
40 return nil, err
41 }
42 return buf.Bytes(), nil
43 }
44 return nil, errors.New("invalid source")
45 }
46 return ioutil.ReadFile(filename)
47 }
48
49
50
51
52
53 type Mode uint
54
55 const (
56 PackageClauseOnly Mode = 1 << iota
57 ImportsOnly
58 ParseComments
59 Trace
60 DeclarationErrors
61 SpuriousErrors
62 AllErrors = SpuriousErrors
63 )
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84 func ParseFile(fset *token.FileSet, filename string, src interface{}, mode Mode) (f *ast.File, err error) {
85 if fset == nil {
86 panic("parser.ParseFile: no token.FileSet provided (fset == nil)")
87 }
88
89
90 text, err := readSource(filename, src)
91 if err != nil {
92 return nil, err
93 }
94
95 var p parser
96 defer func() {
97 if e := recover(); e != nil {
98
99 if _, ok := e.(bailout); !ok {
100 panic(e)
101 }
102 }
103
104
105 if f == nil {
106
107
108
109 f = &ast.File{
110 Name: new(ast.Ident),
111 Scope: ast.NewScope(nil),
112 }
113 }
114
115 p.errors.Sort()
116 err = p.errors.Err()
117 }()
118
119
120 p.init(fset, filename, text, mode)
121 f = p.parseFile()
122
123 return
124 }
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139 func ParseDir(fset *token.FileSet, path string, filter func(os.FileInfo) bool, mode Mode) (pkgs map[string]*ast.Package, first error) {
140 fd, err := os.Open(path)
141 if err != nil {
142 return nil, err
143 }
144 defer fd.Close()
145
146 list, err := fd.Readdir(-1)
147 if err != nil {
148 return nil, err
149 }
150
151 pkgs = make(map[string]*ast.Package)
152 for _, d := range list {
153 if strings.HasSuffix(d.Name(), ".go") && (filter == nil || filter(d)) {
154 filename := filepath.Join(path, d.Name())
155 if src, err := ParseFile(fset, filename, nil, mode); err == nil {
156 name := src.Name.Name
157 pkg, found := pkgs[name]
158 if !found {
159 pkg = &ast.Package{
160 Name: name,
161 Files: make(map[string]*ast.File),
162 }
163 pkgs[name] = pkg
164 }
165 pkg.Files[filename] = src
166 } else if first == nil {
167 first = err
168 }
169 }
170 }
171
172 return
173 }
174
175
176
177
178
179
180 func ParseExprFrom(fset *token.FileSet, filename string, src interface{}, mode Mode) (ast.Expr, error) {
181 if fset == nil {
182 panic("parser.ParseExprFrom: no token.FileSet provided (fset == nil)")
183 }
184
185
186 text, err := readSource(filename, src)
187 if err != nil {
188 return nil, err
189 }
190
191 var p parser
192 defer func() {
193 if e := recover(); e != nil {
194
195 if _, ok := e.(bailout); !ok {
196 panic(e)
197 }
198 }
199 p.errors.Sort()
200 err = p.errors.Err()
201 }()
202
203
204 p.init(fset, filename, text, mode)
205
206
207
208
209 p.openScope()
210 p.pkgScope = p.topScope
211 e := p.parseRhsOrType()
212 p.closeScope()
213 assert(p.topScope == nil, "unbalanced scopes")
214
215
216
217 if p.tok == token.SEMICOLON && p.lit == "\n" {
218 p.next()
219 }
220 p.expect(token.EOF)
221
222 if p.errors.Len() > 0 {
223 p.errors.Sort()
224 return nil, p.errors.Err()
225 }
226
227 return e, nil
228 }
229
230
231
232
233
234 func ParseExpr(x string) (ast.Expr, error) {
235 return ParseExprFrom(token.NewFileSet(), "", []byte(x), 0)
236 }
237
View as plain text