コード例 #1
0
ファイル: gopath.go プロジェクト: johnvilsack/golang-stuff
func (gopaths GoPaths) FindWorkingPath(dir string) (string, error) {
	order := make([]string, len(gopaths))
	copy(order, gopaths)
	sort.Sort(descendingLenStrings(order))

	dir = path.Clean(dir)
	for _, gp := range order {
		if strings.HasPrefix(dir, path.Join(gp, "src")) {
			return gp, nil
		}
	}

	return "", errors.New("working gopath not found")
}
コード例 #2
0
ファイル: table.go プロジェクト: rrudduck/golang-stuff
// add adds t to the structures for global and per-package lookups
func (tt *GlobalNames) Add(t *Named) error {

	// Add type to global type map
	if _, ok := tt.names[t.FullName()]; ok {
		return errors.New("type %s already defined", t.FullName())
	}
	tt.names[t.FullName()] = t

	// Add type to per-package structure
	pkgMap, ok := tt.pkgs[t.PkgPath]
	if !ok {
		pkgMap = make(map[string]*Named)
		tt.pkgs[t.PkgPath] = pkgMap
	}
	pkgMap[t.Name] = t

	return nil
}
コード例 #3
0
ファイル: compile.go プロジェクト: rrudduck/golang-stuff
func compileTypeExpr(pkgPath string, fimp *util.FileImports, expr ast.Expr) (typ Type, err error) {

	switch q := expr.(type) {

	// Built-in types or references to other types in this package
	case *ast.Ident:
		switch q.Name {
		case "bool":
			typ = Builtin[Bool]
		case "int":
			typ = Builtin[Int]
		case "int8":
			typ = Builtin[Int8]
		case "int16":
			typ = Builtin[Int16]
		case "int32":
			typ = Builtin[Int32]
		case "int64":
			typ = Builtin[Int64]
		case "uint":
			typ = Builtin[Uint]
		case "uint8":
			typ = Builtin[Uint8]
		case "uint16":
			typ = Builtin[Uint16]
		case "uint32":
			typ = Builtin[Uint32]
		case "uint64":
			typ = Builtin[Uint64]
		case "uintptr":
			typ = Builtin[Uintptr]
		case "float32":
			typ = Builtin[Float32]
		case "float64":
			typ = Builtin[Float64]
		case "complex64":
			typ = Builtin[Complex64]
		case "complex128":
			typ = Builtin[Complex128]
		case "string":
			typ = Builtin[String]
		default:
			// Name of another type defined in this package
			typ = &Link{PkgPath: pkgPath, Name: q.Name}
		}
		return typ, nil

	case *ast.ParenExpr:
		return compileTypeExpr(pkgPath, fimp, q)

	case *ast.SelectorExpr:
		pkgAlias, ok := q.X.(*ast.Ident)
		if !ok {
			panic("package alias is not an identifier")
		}
		typeName := q.Sel.Name
		impPath, ok := fimp.Alias[pkgAlias.Name]
		if !ok {
			return nil, errors.New("no import with given alias")
		}
		return &Link{PkgPath: impPath, Name: typeName}, nil

	case *ast.StarExpr:
		base, err := compileTypeExpr(pkgPath, fimp, q.X)
		if err != nil {
			return nil, err
		}
		return &Pointer{Base: base}, nil

	case *ast.ArrayType:
		elt, err := compileTypeExpr(pkgPath, fimp, q.Elt)
		if err != nil {
			return nil, err
		}
		if q.Len == nil {
			return &Slice{Elt: elt}, nil
		}
		if _, ok := q.Len.(*ast.Ellipsis); ok {
			return &Array{Len: -1 /*XXX*/, Elt: elt}, nil
		}
		return nil, errors.New("unknown array length")

	case *ast.ChanType:
		value, err := compileTypeExpr(pkgPath, fimp, q.Value)
		if err != nil {
			return nil, err
		}
		return &Chan{Dir: q.Dir, Elt: value}, nil

	case *ast.FuncType:
		// TODO: Compile signature details
		return &Signature{}, nil

	case *ast.InterfaceType:
		// TODO: Compile interface details
		return &Interface{}, nil

	case *ast.MapType:
		key, err := compileTypeExpr(pkgPath, fimp, q.Key)
		if err != nil {
			return nil, err
		}
		value, err := compileTypeExpr(pkgPath, fimp, q.Value)
		if err != nil {
			return nil, err
		}
		return &Map{Key: key, Value: value}, nil

	case *ast.StructType:
		// TODO: Compile struct details
		return &Struct{}, nil
	}

	return nil, errors.New("unexpected type definition")
}