import (
"fmt"
- "sort"
"strconv"
"strings"
"unicode/utf8"
)
func parseFile(filename string) {
- errh := func(_, line int, msg string) {
- yyerrorl(lexlineno+int32(line)-1, "%s", msg)
- }
-
- file, err := syntax.ReadFile(filename, errh, 0)
+ p := noder{baseline: lexlineno}
+ file, err := syntax.ReadFile(filename, p.error, p.pragma, 0)
if err != nil {
Fatalf("syntax.ReadFile %s: %v", filename, err)
}
- p := noder{pragmas: file.Pragmas}
-
- p.lineno(file.PkgName)
- mkpackage(file.PkgName.Value)
+ p.file(file)
- xtop = append(xtop, p.decls(file.DeclList, true)...)
- p.globalPragmas()
- lexlineno += p.maxline
+ if !imported_unsafe {
+ for _, x := range p.linknames {
+ p.error(0, x, "//go:linkname only allowed in Go files that import \"unsafe\"")
+ }
+ }
if nsyntaxerrors == 0 {
testdclstack()
// noder transforms package syntax's AST into a Nod tree.
type noder struct {
- indent []byte
- pragmas []syntax.Pragma
- pline int32
- maxline int32
+ baseline int32
+ linknames []int // tracks //go:linkname lines
}
-func (p *noder) decls(decls []syntax.Decl, top bool) (l []*Node) {
+func (p *noder) file(file *syntax.File) {
+ p.lineno(file.PkgName)
+ mkpackage(file.PkgName.Value)
+
+ xtop = append(xtop, p.decls(file.DeclList)...)
+
+ lexlineno = p.baseline + int32(file.Lines) - 1
+ lineno = lexlineno
+}
+
+func (p *noder) decls(decls []syntax.Decl) (l []*Node) {
var lastConstGroup *syntax.Group
var lastConstRHS []*Node
var iotaVal int32
case *syntax.VarDecl:
l = append(l, p.varDecl(decl)...)
+
case *syntax.ConstDecl:
// Tricky to handle golang.org/issue/15550 correctly.
default:
panic("unhandled Decl")
}
-
- if top {
- p.pline = p.maxline
- }
}
return
func (p *noder) importDecl(imp *syntax.ImportDecl) {
val := p.basicLit(imp.Path)
- importfile(&val, p.indent)
+ importfile(&val, nil)
ipkg := importpkg
importpkg = nil
exprs = p.exprList(decl.Values)
}
+ p.lineno(decl)
return variter(names, typ, exprs)
}
}
}
- pragma := p.pragma()
+ pragma := Pragma(fun.Pragma)
f.Nbody.Set(body)
f.Noescape = pragma&Noescape != 0
Yyerror("can only use //go:noescape with external func implementations")
}
f.Func.Pragma = pragma
- lineno = lexlineno + int32(fun.EndLine) - 1
+ lineno = p.baseline + int32(fun.EndLine) - 1
f.Func.Endlineno = lineno
funcbody(f)
if expr.Type != nil {
n.Right = p.expr(expr.Type)
}
- // TODO(mdempsky): Should apply wrapname to n.List nodes.
- n.List.Set(p.exprs(expr.ElemList))
+ l := p.exprs(expr.ElemList)
+ for i, e := range l {
+ l[i] = p.wrapname(expr.ElemList[i], e)
+ }
+ n.List.Set(l)
+ lineno = p.baseline + int32(expr.EndLine) - 1
return n
case *syntax.KeyValueExpr:
return p.nod(expr, OKEY, p.expr(expr.Key), p.wrapname(expr.Value, p.expr(expr.Value)))
case *syntax.FuncLit:
closurehdr(p.typeExpr(expr.Type))
body := p.stmts(expr.Body)
- lineno = lexlineno + int32(expr.EndLine) - 1
+ lineno = p.baseline + int32(expr.EndLine) - 1
return p.setlineno(expr, closurebody(body))
case *syntax.ParenExpr:
return p.nod(expr, OPAREN, p.expr(expr.X), nil)
x = unparen(x) // TODO(mdempsky): Needed?
if x.Op == OCOMPLIT {
// Special case for &T{...}: turn into (*T){...}.
- x.Right = p.nod(expr, OIND, x.Right, nil)
+ // TODO(mdempsky): Switch back to p.nod after we
+ // get rid of gcCompat.
+ x.Right = Nod(OIND, x.Right, nil)
x.Right.Implicit = true
return x
}
case *syntax.SendStmt:
return p.nod(stmt, OSEND, p.expr(stmt.Chan), p.expr(stmt.Value))
case *syntax.DeclStmt:
- return liststmt(p.decls(stmt.DeclList, false))
+ return liststmt(p.decls(stmt.DeclList))
case *syntax.AssignStmt:
if stmt.Op != 0 && stmt.Op != syntax.Def {
n := p.nod(stmt, OASOP, p.expr(stmt.Lhs), p.expr(stmt.Rhs))
// TODO(mdempsky): Shouldn't happen. Fix package syntax.
return dst
}
- if l > p.maxline {
- p.maxline = l
- }
- dst.Lineno = lexlineno + l - 1
+ dst.Lineno = p.baseline + l - 1
return dst
}
// TODO(mdempsky): Shouldn't happen. Fix package syntax.
return
}
- if l > p.maxline {
- p.maxline = l
- }
- lineno = lexlineno + l - 1
+ lineno = p.baseline + l - 1
}
-func (p *noder) pragma() Pragma {
- lo := sort.Search(len(p.pragmas), func(i int) bool { return int32(p.pragmas[i].Line) >= p.pline })
- hi := sort.Search(len(p.pragmas), func(i int) bool { return int32(p.pragmas[i].Line) > p.maxline })
+func (p *noder) error(_, line int, msg string) {
+ yyerrorl(p.baseline+int32(line)-1, "%s", msg)
+}
- var res Pragma
- for _, prag := range p.pragmas[lo:hi] {
- text := prag.Text
- if !strings.HasPrefix(text, "go:") {
- continue
+func (p *noder) pragma(pos, line int, text string) syntax.Pragma {
+ switch {
+ case strings.HasPrefix(text, "line "):
+ i := strings.IndexByte(text, ':')
+ if i < 0 {
+ break
+ }
+ n, err := strconv.Atoi(text[i+1:])
+ if err != nil {
+ // todo: make this an error instead? it is almost certainly a bug.
+ break
}
+ if n > 1e8 {
+ p.error(pos, line, "line number out of range")
+ errorexit()
+ }
+ if n <= 0 {
+ break
+ }
+ lexlineno = p.baseline + int32(line)
+ linehistupdate(text[5:i], n)
+
+ case strings.HasPrefix(text, "go:linkname "):
+ // Record line number so we can emit an error later if
+ // the file doesn't import package unsafe.
+ p.linknames = append(p.linknames, line)
+
+ f := strings.Fields(text)
+ if len(f) != 3 {
+ p.error(pos, line, "usage: //go:linkname localname linkname")
+ break
+ }
+ Lookup(f[1]).Linkname = f[2]
+ case strings.HasPrefix(text, "go:cgo_"):
+ pragcgobuf += pragcgo(text)
+ fallthrough // because of //go:cgo_unsafe_args
+ default:
verb := text
if i := strings.Index(text, " "); i >= 0 {
verb = verb[:i]
}
-
- res |= PragmaValue(verb)
+ return syntax.Pragma(PragmaValue(verb))
}
- return res
-}
-
-func (p *noder) globalPragmas() {
- origlexlineno := lexlineno
- defer func() {
- lexlineno = origlexlineno
- }()
-
- for _, prag := range p.pragmas {
- text := prag.Text
-
- if strings.HasPrefix(text, "go:cgo_") {
- pragcgobuf += pragcgo(text)
- }
- if strings.HasPrefix(text, "go:linkname ") {
- if !imported_unsafe {
- Yyerror("//go:linkname only allowed in Go files that import \"unsafe\"")
- }
- f := strings.Fields(text)
- if len(f) != 3 {
- Yyerror("usage: //go:linkname localname linkname")
- break
- }
- Lookup(f[1]).Linkname = f[2]
- }
-
- // TODO(mdempsky): Move into package syntax.
- if strings.HasPrefix(text, "line ") {
- i := strings.IndexByte(text, ':')
- if i < 0 {
- continue
- }
- n, err := strconv.Atoi(text[i+1:])
- if err != nil {
- // todo: make this an error instead? it is almost certainly a bug.
- continue
- }
- if n > 1e8 {
- Yyerror("line number out of range")
- errorexit()
- }
- if n <= 0 {
- continue
- }
- lexlineno = origlexlineno + int32(prag.Line)
- linehistupdate(text[5:i], n)
- }
- }
+ return 0
}
nerrors int // error count
}
-func (p *parser) init(src io.Reader, errh ErrorHandler) {
+func (p *parser) init(src io.Reader, errh ErrorHandler, pragh PragmaHandler) {
p.scanner.init(src, func(pos, line int, msg string) {
p.nerrors++
if !debug && errh != nil {
return
}
panic(fmt.Sprintf("%d: %s\n", line, msg))
- })
+ }, pragh)
p.fnest = 0
p.xnest = 0
continue
}
+ // Reset p.pragma BEFORE advancing to the next token (consuming ';')
+ // since comments before may set pragmas for the next function decl.
+ p.pragma = 0
+
if p.tok != _EOF && !p.got(_Semi) {
p.syntax_error("after top level declaration")
p.advance(_Const, _Type, _Var, _Func)
// p.tok == _EOF
f.Lines = p.source.line
- f.Pragmas = p.pragmas
return f
}
}
}
d.Group = group
+ if gcCompat {
+ d.init(p)
+ }
return d
}
f.Name = p.name()
f.Type = p.funcType()
+ if gcCompat {
+ f.node = f.Type.node
+ }
f.Body = p.funcBody()
+ f.Pragma = p.pragma
f.EndLine = uint32(p.line)
// TODO(gri) deal with function properties
tprec := p.prec
p.next()
t.Y = p.binaryExpr(tprec)
+ if gcCompat {
+ t.init(p)
+ }
x = t
}
return x
x.Op = p.op
p.next()
x.X = p.unaryExpr()
+ if gcCompat {
+ x.init(p)
+ }
return x
case And:
p.syntax_error("expecting name or (")
p.advance(_Semi, _Rparen)
}
+ if gcCompat {
+ x.init(p)
+ }
case _Lbrack:
p.next()
l.init(p)
l.Key = e
l.Value = p.bare_complitexpr()
+ if gcCompat {
+ l.init(p)
+ }
e = l
x.NKeys++
}
}
}
+ x.EndLine = uint32(p.line)
p.xnest--
p.want(_Rbrace)
typ.init(p)
typ.ParamList = p.paramList()
typ.ResultList = p.funcResult()
+ if gcCompat {
+ typ.init(p)
+ }
return typ
}
f.Type = typ
styp.FieldList = append(styp.FieldList, f)
+ if gcCompat && name != nil {
+ f.node = name.node
+ }
+
if debug && tag != nil && len(styp.FieldList) != len(styp.TagList) {
panic("inconsistent struct field list")
}
s.init(p)
s.Chan = lhs
s.Value = p.expr()
+ if gcCompat {
+ s.init(p)
+ }
return s
default:
r.Lhs = lhs
r.Def = def
r.X = p.expr()
+ if gcCompat {
+ r.init(p)
+ }
return r
}
p.want(_For)
s.Init, s.Cond, s.Post = p.header(true)
+ if gcCompat {
+ s.init(p)
+ }
s.Body = p.stmtBody("for clause")
return s
p.error("missing condition in if statement")
}
+ if gcCompat {
+ s.init(p)
+ }
+
s.Then = p.stmtBody("if clause")
if p.got(_Else) {
if p.tok != _Semi && p.tok != _Rbrace {
s.Results = p.exprList()
}
+ if gcCompat {
+ s.init(p)
+ }
return s
case _Semi:
type Mode uint
+// A Pragma value is a set of flags that augment a function
+// declaration. Callers may assign meaning to the flags as
+// appropriate.
+type Pragma uint16
+
type ErrorHandler func(pos, line int, msg string)
+// A PragmaHandler is used to process //line and //go: directives as
+// they're scanned. The returned Pragma value will be unioned into the
+// next FuncDecl node.
+type PragmaHandler func(pos, line int, text string) Pragma
+
// TODO(gri) These need a lot more work.
-func ReadFile(filename string, errh ErrorHandler, mode Mode) (*File, error) {
+func ReadFile(filename string, errh ErrorHandler, pragh PragmaHandler, mode Mode) (*File, error) {
src, err := os.Open(filename)
if err != nil {
return nil, err
}
defer src.Close()
- return Read(src, errh, mode)
+ return Read(src, errh, pragh, mode)
}
type bytesReader struct {
return 0, io.EOF
}
-func ReadBytes(src []byte, errh ErrorHandler, mode Mode) (*File, error) {
- return Read(&bytesReader{src}, errh, mode)
+func ReadBytes(src []byte, errh ErrorHandler, pragh PragmaHandler, mode Mode) (*File, error) {
+ return Read(&bytesReader{src}, errh, pragh, mode)
}
-func Read(src io.Reader, errh ErrorHandler, mode Mode) (*File, error) {
+func Read(src io.Reader, errh ErrorHandler, pragh PragmaHandler, mode Mode) (*File, error) {
var p parser
- p.init(src, errh)
+ p.init(src, errh, pragh)
p.next()
ast := p.file()