func (w *World) CompileStmtList(fset *token.FileSet, stmts []ast.Stmt) (Code, error) {
if len(stmts) == 1 {
if s, ok := stmts[0].(*ast.ExprStmt); ok {
return w.CompileExpr(fset, s.X)
}
}
errors := new(scanner.ErrorList)
cc := &compiler{fset, errors, 0, 0}
cb := newCodeBuf()
fc := &funcCompiler{
compiler: cc,
fnType: nil,
outVarsNamed: false,
codeBuf: cb,
flow: newFlowBuf(cb),
labels: make(map[string]*label),
}
bc := &blockCompiler{
funcCompiler: fc,
block: w.scope.block,
}
nerr := cc.numError()
for _, stmt := range stmts {
bc.compileStmt(stmt)
}
fc.checkLabels()
if nerr != cc.numError() {
errors.Sort()
return nil, errors.Err()
}
return &stmtCode{w, fc.get()}, nil
}
// ResolveQualifiedIdents resolves the selectors of qualified
// identifiers by associating the correct ast.Object with them.
// TODO(gri): Eventually, this functionality should be subsumed
// by Check.
//
func ResolveQualifiedIdents(fset *token.FileSet, pkg *ast.Package) error {
var errors scanner.ErrorList
findObj := func(pkg *ast.Object, name *ast.Ident) *ast.Object {
scope := pkg.Data.(*ast.Scope)
obj := scope.Lookup(name.Name)
if obj == nil {
errors.Add(fset.Position(name.Pos()), fmt.Sprintf("no %s in package %s", name.Name, pkg.Name))
}
return obj
}
ast.Inspect(pkg, func(n ast.Node) bool {
if s, ok := n.(*ast.SelectorExpr); ok {
if x, ok := s.X.(*ast.Ident); ok && x.Obj != nil && x.Obj.Kind == ast.Pkg {
// find selector in respective package
s.Sel.Obj = findObj(x.Obj, s.Sel)
}
return false
}
return true
})
return errors.Err()
}
func (c *compiler) VisitDecl(decl ast.Decl) Value {
c.setDebugLine(decl.Pos())
// This is temporary. We'll return errors later, rather than panicking.
if c.Logger != nil {
c.Logger.Println("Compile declaration:", c.fileset.Position(decl.Pos()))
}
defer func() {
if e := recover(); e != nil {
elist := new(scanner.ErrorList)
elist.Add(c.fileset.Position(decl.Pos()), fmt.Sprint(e))
panic(elist)
}
}()
switch x := decl.(type) {
case *ast.FuncDecl:
return c.VisitFuncDecl(x)
case *ast.GenDecl:
c.VisitGenDecl(x)
return nil
}
panic(fmt.Sprintf("Unhandled decl (%s) at %s\n",
reflect.TypeOf(decl),
c.fileset.Position(decl.Pos())))
}
func HandleScannerError(errList scanner.ErrorList) {
fmt.Fprintf(os.Stderr, "%d errors\n", errList.Len())
maxErrs := 10
errCount := 0
for _, scannerErr := range errList {
if errCount == maxErrs {
fmt.Fprint(os.Stderr, "too many errors")
break
}
errCount++
fmt.Fprintf(os.Stderr, "Error: %v\n", scannerErr)
}
os.Exit(1)
}
func checkFiles(t *testing.T, testname string, testfiles []string) {
// TODO(gri) Eventually all these different phases should be
// subsumed into a single function call that takes
// a set of files and creates a fully resolved and
// type-checked AST.
files, err := parseFiles(t, testname, testfiles)
// we are expecting the following errors
// (collect these after parsing the files so that
// they are found in the file set)
errors := expectedErrors(t, testname, files)
// verify errors returned by the parser
eliminate(t, errors, err)
// verify errors returned after resolving identifiers
pkg, err := ast.NewPackage(fset, files, GcImport, Universe)
eliminate(t, errors, err)
// verify errors returned by the typechecker
var list scanner.ErrorList
errh := func(pos token.Pos, msg string) {
list.Add(fset.Position(pos), msg)
}
err = Check(fset, pkg, errh, nil)
eliminate(t, errors, list)
if *listErrors {
scanner.PrintError(os.Stdout, err)
return
}
// there should be no expected errors left
if len(errors) > 0 {
t.Errorf("%s: %d errors not reported:", testname, len(errors))
for pos, msg := range errors {
t.Errorf("%s: %s\n", fset.Position(pos), msg)
}
}
}
func (w *World) CompileExpr(fset *token.FileSet, e ast.Expr) (Code, error) {
errors := new(scanner.ErrorList)
cc := &compiler{fset, errors, 0, 0}
ec := cc.compileExpr(w.scope.block, false, e)
if ec == nil {
errors.Sort()
return nil, errors.Err()
}
var eval func(Value, *Thread)
switch t := ec.t.(type) {
case *idealIntType:
// nothing
case *idealFloatType:
// nothing
default:
if tm, ok := t.(*MultiType); ok && len(tm.Elems) == 0 {
return &stmtCode{w, code{ec.exec}}, nil
}
eval = genAssign(ec.t, ec)
}
return &exprCode{w, ec, eval}, nil
}
func (p *Parser) Ast(fs *token.FileSet, path string, files []string, unsaved map[string]UnsavedDocument) (*ast.File, []*ast.File, error) {
ret := make([]*ast.File, len(files))
var retf *ast.File
var errors scanner.ErrorList
for i, f := range files {
f = CanonicalPath(f)
var v *ast.File
var err error
if uns, ok := unsaved[f]; ok {
v, err = parser.ParseFile(fs, f, uns.Data, parser.AllErrors)
} else {
v, err = p.fromCache(fs, f)
}
if v == nil {
return nil, nil, err
}
ret[i] = v
if path == f {
retf = ret[i]
if perr, ok := err.(scanner.ErrorList); ok {
for _, e := range perr {
errors.Add(e.Pos, e.Msg)
}
}
}
}
errors.RemoveMultiples()
errors.Sort()
var err error
if len(errors) != 0 {
err = errors
}
return retf, ret, err
}
func processFile(filename string) ([]*prototype, error) {
info, err := os.Stat(filename)
if err != nil {
return nil, err
}
src, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
// Scan file
protos := make([]*prototype, 0)
var errorList scanner.ErrorList
var s scanner.Scanner
fset := token.NewFileSet()
file := fset.AddFile(filename, fset.Base(), int(info.Size()))
s.Init(file, src, nil, scanner.ScanComments)
for findPkg, isPkgToken := true, false; ; {
_, tok, lit := s.Scan()
if tok == token.EOF {
break
}
// package name
if findPkg {
if tok == token.PACKAGE {
isPkgToken = true
continue
}
if isPkgToken {
if PKG_NAME == "" {
PKG_NAME = lit
if PKG_NAME == "syscall" {
SYSCALL_DOT = ""
}
} else if PKG_NAME != lit {
return nil, errors.New("the files have different package name")
}
findPkg = false
continue
}
}
// scan comments
if tok != token.COMMENT || !strings.HasPrefix(lit, PREFIX) {
continue
}
lit = strings.Replace(lit, PREFIX, "", 1)
if lit[0] != ' ' && lit[0] != '\t' {
continue
}
lit = strings.TrimSpace(lit)
proto, err := scanProtype([]byte(lit))
if err != nil {
errorList.Add(err.Pos, err.Msg)
continue
}
if errorList.Len() == 0 {
protos = append(protos, proto)
}
}
if errorList.Len() != 0 {
return nil, errorList
}
return protos, nil
}
func processFile(filename string, proto *prototype) error {
info, err := os.Stat(filename)
if err != nil {
return err
}
src, err := ioutil.ReadFile(filename)
if err != nil {
return err
}
// Scan file
var errorList scanner.ErrorList
var s scanner.Scanner
fset := token.NewFileSet()
file := fset.AddFile(filename, fset.Base(), int(info.Size()))
s.Init(file, src, nil, scanner.ScanComments)
for findPkg, isPkgToken := true, false; ; {
_, tok, lit := s.Scan()
if tok == token.EOF {
break
}
// package name
if findPkg {
if tok == token.PACKAGE {
isPkgToken = true
continue
}
if isPkgToken {
if proto.pkgName == "" {
(*proto).pkgName = lit
} else if proto.pkgName != lit {
return errors.New("the files have different package name")
}
findPkg = false
continue
}
}
// scan comments
if tok != token.COMMENT || !strings.HasPrefix(lit, PREFIX) {
continue
}
lit = strings.Replace(lit, PREFIX, "", 1)
if lit[0] == '/' && lit[1] == '/' {
proto.comment = lit
continue
}
if lit[0] != ' ' && lit[0] != '\t' {
continue
}
lit_ := strings.TrimSpace(lit)
// multiple comments
for {
if lit[len(lit)-1] == ',' { // the line continues on the next one
_, tok, lit = s.Scan()
if tok == token.COMMENT {
lit = strings.Replace(lit, "//", "", 1)
lit = strings.TrimSpace(lit)
lit_ += lit
} else {
break
}
} else {
break
}
}
err := scanProtype(proto, []byte(lit_))
if err != nil {
errorList.Add(err.Pos, err.Msg)
continue
}
}
if errorList.Len() != 0 {
return errorList
}
return nil
}