//export AddProvide
func AddProvide(cTarget uintptr, cLanguage *C.char, cDep *C.char) *C.char {
target := unsizet(cTarget)
label, err := core.TryParseBuildLabel(C.GoString(cDep), target.Label.PackageName)
if err != nil {
return C.CString(err.Error())
}
target.AddProvide(C.GoString(cLanguage), label)
return nil
}
//export AddExportedDep
func AddExportedDep(cTarget uintptr, cDep *C.char) *C.char {
target := unsizet(cTarget)
dep, err := core.TryParseBuildLabel(C.GoString(cDep), target.Label.PackageName)
if err != nil {
return C.CString(err.Error())
}
target.AddMaybeExportedDependency(dep, true)
return nil
}
//export AddVis
func AddVis(cTarget uintptr, cVis *C.char) *C.char {
target := unsizet(cTarget)
vis := C.GoString(cVis)
if vis == "PUBLIC" || (core.State.Config.Bazel.Compatibility && vis == "//visibility:public") {
target.Visibility = append(target.Visibility, core.WholeGraph[0])
} else {
label, err := core.TryParseBuildLabel(vis, target.Label.PackageName)
if err != nil {
return C.CString(err.Error())
}
target.Visibility = append(target.Visibility, label)
}
return nil
}
//export AddDependency
func AddDependency(cPackage uintptr, cTarget *C.char, cDep *C.char, exported bool) *C.char {
target, err := getTargetPost(cPackage, cTarget)
if err != nil {
return C.CString(err.Error())
}
dep, err := core.TryParseBuildLabel(C.GoString(cDep), target.Label.PackageName)
if err != nil {
return C.CString(err.Error())
}
target.AddMaybeExportedDependency(dep, exported)
// Note that here we're in a post-build function so we must call this explicitly
// (in other callbacks it's handled after the package parses all at once).
core.State.Graph.AddDependency(target.Label, dep)
return nil
}
//export GetLabels
func GetLabels(cPackage uintptr, cTarget *C.char, cPrefix *C.char) **C.char {
// Two formats are supported here: either passing just the name of a target in the current
// package, or a build label referring specifically to one.
lbl := C.GoString(cTarget)
prefix := C.GoString(cPrefix)
if core.LooksLikeABuildLabel(lbl) {
label, err := core.TryParseBuildLabel(lbl, unsizep(cPackage).Name)
if err != nil {
log.Fatalf("%s", err) // TODO(pebers): report proper errors here and below
}
return stringSliceToCStringArray(getLabels(core.State.Graph.TargetOrDie(label), prefix, core.Built))
}
target, err := getTargetPost(cPackage, cTarget)
if err != nil {
log.Fatalf("%s", err)
}
return stringSliceToCStringArray(getLabels(target, prefix, core.Building))
}
// Parses an incoming source label as either a file or a build label.
// Identifies if the file is owned by this package and returns an error if not.
func parseSource(src, packageName string, systemAllowed bool) (core.BuildInput, error) {
if core.LooksLikeABuildLabel(src) {
return core.TryParseBuildLabel(src, packageName)
} else if src == "" {
return nil, fmt.Errorf("Empty source path (in package %s)", packageName)
} else if strings.Contains(src, "../") {
return nil, fmt.Errorf("'%s' (in package %s) is an invalid path; build target paths can't contain ../", src, packageName)
} else if src[0] == '/' || src[0] == '~' {
if !systemAllowed {
return nil, fmt.Errorf("'%s' (in package %s) is an absolute path; that's not allowed.", src, packageName)
}
return core.SystemFileLabel{Path: core.ExpandHomePath(src)}, nil
} else if strings.Contains(src, "/") {
// Target is in a subdirectory, check nobody else owns that.
for dir := path.Dir(path.Join(packageName, src)); dir != packageName && dir != "."; dir = path.Dir(dir) {
if core.IsPackage(dir) {
return nil, fmt.Errorf("Package %s tries to use file %s, but that belongs to another package (%s).", packageName, src, dir)
}
}
}
return core.FileLabel{File: src, Package: packageName}, nil
}