| // Copyright 2010 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Wrappers for Go parser. |
| |
| package main |
| |
| import ( |
| "go/ast" |
| "go/parser" |
| "log" |
| "os" |
| "path/filepath" |
| "strconv" |
| "strings" |
| "runtime" |
| ) |
| |
| |
| type dirInfo struct { |
| goFiles []string // .go files within dir (including cgoFiles) |
| cgoFiles []string // .go files that import "C" |
| cFiles []string // .c files within dir |
| sFiles []string // .s files within dir |
| imports []string // All packages imported by goFiles |
| pkgName string // Name of package within dir |
| } |
| |
| // scanDir returns a structure with details about the Go content found |
| // in the given directory. The list of files will NOT contain the |
| // following entries: |
| // |
| // - Files in package main (unless allowMain is true) |
| // - Files ending in _test.go |
| // - Files starting with _ (temporary) |
| // - Files containing .cgo in their names |
| // |
| // The imports map keys are package paths imported by listed Go files, |
| // and the values are the Go files importing the respective package paths. |
| func scanDir(dir string, allowMain bool) (info *dirInfo, err os.Error) { |
| f, err := os.Open(dir, os.O_RDONLY, 0) |
| if err != nil { |
| return nil, err |
| } |
| dirs, err := f.Readdir(-1) |
| f.Close() |
| if err != nil { |
| return nil, err |
| } |
| |
| goFiles := make([]string, 0, len(dirs)) |
| cgoFiles := make([]string, 0, len(dirs)) |
| cFiles := make([]string, 0, len(dirs)) |
| sFiles := make([]string, 0, len(dirs)) |
| importsm := make(map[string]bool) |
| pkgName := "" |
| for i := range dirs { |
| d := &dirs[i] |
| if strings.HasPrefix(d.Name, "_") || strings.Index(d.Name, ".cgo") != -1 { |
| continue |
| } |
| if !goodOSArch(d.Name) { |
| continue |
| } |
| |
| switch filepath.Ext(d.Name) { |
| case ".go": |
| if strings.HasSuffix(d.Name, "_test.go") { |
| continue |
| } |
| case ".c": |
| cFiles = append(cFiles, d.Name) |
| continue |
| case ".s": |
| sFiles = append(sFiles, d.Name) |
| continue |
| default: |
| continue |
| } |
| |
| filename := filepath.Join(dir, d.Name) |
| pf, err := parser.ParseFile(fset, filename, nil, parser.ImportsOnly) |
| if err != nil { |
| return nil, err |
| } |
| s := string(pf.Name.Name) |
| if s == "main" && !allowMain { |
| continue |
| } |
| if pkgName == "" { |
| pkgName = s |
| } else if pkgName != s { |
| // Only if all files in the directory are in package main |
| // do we return pkgName=="main". |
| // A mix of main and another package reverts |
| // to the original (allowMain=false) behaviour. |
| if s == "main" || pkgName == "main" { |
| return scanDir(dir, false) |
| } |
| return nil, os.ErrorString("multiple package names in " + dir) |
| } |
| goFiles = append(goFiles, d.Name) |
| for _, decl := range pf.Decls { |
| for _, spec := range decl.(*ast.GenDecl).Specs { |
| quoted := string(spec.(*ast.ImportSpec).Path.Value) |
| unquoted, err := strconv.Unquote(quoted) |
| if err != nil { |
| log.Panicf("%s: parser returned invalid quoted string: <%s>", filename, quoted) |
| } |
| importsm[unquoted] = true |
| if unquoted == "C" { |
| cgoFiles = append(cgoFiles, d.Name) |
| } |
| } |
| } |
| } |
| imports := make([]string, len(importsm)) |
| i := 0 |
| for p := range importsm { |
| imports[i] = p |
| i++ |
| } |
| return &dirInfo{goFiles, cgoFiles, cFiles, sFiles, imports, pkgName}, nil |
| } |
| |
| // goodOSArch returns false if the filename contains a $GOOS or $GOARCH |
| // suffix which does not match the current system. |
| // The recognized filename formats are: |
| // |
| // name_$(GOOS).* |
| // name_$(GOARCH).* |
| // name_$(GOOS)_$(GOARCH).* |
| // |
| func goodOSArch(filename string) bool { |
| if dot := strings.Index(filename, "."); dot != -1 { |
| filename = filename[:dot] |
| } |
| l := strings.Split(filename, "_", -1) |
| n := len(l) |
| if n == 0 { |
| return true |
| } |
| if good, known := goodOS[l[n-1]]; known { |
| return good |
| } |
| if good, known := goodArch[l[n-1]]; known { |
| if !good || n < 2 { |
| return false |
| } |
| good, known = goodOS[l[n-2]] |
| return good || !known |
| } |
| return true |
| } |
| |
| var goodOS = make(map[string]bool) |
| var goodArch = make(map[string]bool) |
| |
| func init() { |
| goodOS = make(map[string]bool) |
| goodArch = make(map[string]bool) |
| for _, v := range strings.Fields(goosList) { |
| goodOS[v] = v == runtime.GOOS |
| } |
| for _, v := range strings.Fields(goarchList) { |
| goodArch[v] = v == runtime.GOARCH |
| } |
| } |