Subversion Repositories openrisc

// Copyright 2011 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.

package build

import (
        "errors"
        "fmt"
        "os"
        "path/filepath"
        "runtime"
)

// Path is a validated list of Trees derived from $GOROOT and $GOPATH at init.
var Path []*Tree

// Tree describes a Go source tree, either $GOROOT or one from $GOPATH.
type Tree struct {
        Path   string
        Goroot bool
}

func newTree(p string) (*Tree, error) {
        if !filepath.IsAbs(p) {
                return nil, errors.New("must be absolute")
        }
        ep, err := filepath.EvalSymlinks(p)
        if err != nil {
                return nil, err
        }
        return &Tree{Path: ep}, nil
}

// SrcDir returns the tree's package source directory.
func (t *Tree) SrcDir() string {
        if t.Goroot {
                return filepath.Join(t.Path, "src", "pkg")
        }
        return filepath.Join(t.Path, "src")
}

// PkgDir returns the tree's package object directory.
func (t *Tree) PkgDir() string {
        goos, goarch := runtime.GOOS, runtime.GOARCH
        if e := os.Getenv("GOOS"); e != "" {
                goos = e
        }
        if e := os.Getenv("GOARCH"); e != "" {
                goarch = e
        }
        return filepath.Join(t.Path, "pkg", goos+"_"+goarch)
}

// BinDir returns the tree's binary executable directory.
func (t *Tree) BinDir() string {
        if t.Goroot {
                if gobin := os.Getenv("GOBIN"); gobin != "" {
                        return filepath.Clean(gobin)
                }
        }
        return filepath.Join(t.Path, "bin")
}

// HasSrc returns whether the given package's
// source can be found inside this Tree.
func (t *Tree) HasSrc(pkg string) bool {
        fi, err := os.Stat(filepath.Join(t.SrcDir(), pkg))
        if err != nil {
                return false
        }
        return fi.IsDir()
}

// HasPkg returns whether the given package's
// object file can be found inside this Tree.
func (t *Tree) HasPkg(pkg string) bool {
        fi, err := os.Stat(filepath.Join(t.PkgDir(), pkg+".a"))
        if err != nil {
                return false
        }
        return !fi.IsDir()
}

var (
        ErrNotFound     = errors.New("package could not be found locally")
        ErrTreeNotFound = errors.New("no valid GOROOT or GOPATH could be found")
)

// FindTree takes an import or filesystem path and returns the
// tree where the package source should be and the package import path.
func FindTree(path string) (tree *Tree, pkg string, err error) {
        if isLocalPath(path) {
                if path, err = filepath.Abs(path); err != nil {
                        return
                }
                if path, err = filepath.EvalSymlinks(path); err != nil {
                        return
                }
                for _, t := range Path {
                        tpath := t.SrcDir() + string(filepath.Separator)
                        if !filepath.HasPrefix(path, tpath) {
                                continue
                        }
                        tree = t
                        pkg = filepath.ToSlash(path[len(tpath):])
                        return
                }
                err = fmt.Errorf("path %q not inside a GOPATH", path)
                return
        }
        tree = defaultTree
        pkg = filepath.ToSlash(path)
        for _, t := range Path {
                if t.HasSrc(pkg) {
                        tree = t
                        return
                }
        }
        if tree == nil {
                err = ErrTreeNotFound
        } else {
                err = ErrNotFound
        }
        return
}

// isLocalPath returns whether the given path is local (/foo ./foo ../foo . ..)
// Windows paths that starts with drive letter (c:\foo c:foo) are considered local.
func isLocalPath(s string) bool {
        const sep = string(filepath.Separator)
        return s == "." || s == ".." ||
                filepath.HasPrefix(s, sep) ||
                filepath.HasPrefix(s, "."+sep) || filepath.HasPrefix(s, ".."+sep) ||
                filepath.VolumeName(s) != ""
}

var (
        // argument lists used by the build's gc and ld methods
        gcImportArgs []string
        ldImportArgs []string

        // default tree for remote packages
        defaultTree *Tree
)

// set up Path: parse and validate GOROOT and GOPATH variables
func init() {
        root := runtime.GOROOT()
        t, err := newTree(root)
        if err == nil {
                t.Goroot = true
                Path = []*Tree{t}
        }

        for _, p := range filepath.SplitList(os.Getenv("GOPATH")) {
                if p == "" {
                        continue
                }
                t, err := newTree(p)
                if err != nil {
                        continue
                }

                Path = append(Path, t)
                gcImportArgs = append(gcImportArgs, "-I", t.PkgDir())
                ldImportArgs = append(ldImportArgs, "-L", t.PkgDir())

                // select first GOPATH entry as default
                if defaultTree == nil {
                        defaultTree = t
                }
        }

        // use GOROOT if no valid GOPATH specified
        if defaultTree == nil && len(Path) > 0 {
                defaultTree = Path[0]
        }
}