250 lines
8 KiB
Go
250 lines
8 KiB
Go
// Package builders provides build implementations for different project types.
|
|
package builders
|
|
|
|
import (
|
|
"context"
|
|
"runtime"
|
|
|
|
"dappco.re/go/core"
|
|
"dappco.re/go/core/build/internal/ax"
|
|
"dappco.re/go/core/build/pkg/build"
|
|
"dappco.re/go/core/io"
|
|
coreerr "dappco.re/go/core/log"
|
|
)
|
|
|
|
// CPPBuilder implements the Builder interface for C++ projects using CMake + Conan.
|
|
// It wraps the Makefile-based build system from the .core/build submodule.
|
|
// Usage example: declare a value of type builders.CPPBuilder in integrating code.
|
|
type CPPBuilder struct{}
|
|
|
|
// NewCPPBuilder creates a new CPPBuilder instance.
|
|
// Usage example: call builders.NewCPPBuilder(...) from integrating code.
|
|
func NewCPPBuilder() *CPPBuilder {
|
|
return &CPPBuilder{}
|
|
}
|
|
|
|
// Name returns the builder's identifier.
|
|
// Usage example: call value.Name(...) from integrating code.
|
|
func (b *CPPBuilder) Name() string {
|
|
return "cpp"
|
|
}
|
|
|
|
// Detect checks if this builder can handle the project in the given directory.
|
|
// Usage example: call value.Detect(...) from integrating code.
|
|
func (b *CPPBuilder) Detect(fs io.Medium, dir string) (bool, error) {
|
|
return build.IsCPPProject(fs, dir), nil
|
|
}
|
|
|
|
// Build compiles the C++ project using Make targets.
|
|
// The build flow is: make configure → make build → make package.
|
|
// Cross-compilation is handled via Conan profiles specified in .core/build.yaml.
|
|
// Usage example: call value.Build(...) from integrating code.
|
|
func (b *CPPBuilder) Build(ctx context.Context, cfg *build.Config, targets []build.Target) ([]build.Artifact, error) {
|
|
if cfg == nil {
|
|
return nil, coreerr.E("CPPBuilder.Build", "config is nil", nil)
|
|
}
|
|
|
|
// Validate make is available
|
|
if err := b.validateMake(); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// For C++ projects, the Makefile handles everything.
|
|
// We don't iterate per-target like Go — the Makefile's configure + build
|
|
// produces binaries for the host platform, and cross-compilation uses
|
|
// named Conan profiles (e.g., make gcc-linux-armv8).
|
|
if len(targets) == 0 {
|
|
// Default to host platform
|
|
targets = []build.Target{{OS: runtime.GOOS, Arch: runtime.GOARCH}}
|
|
}
|
|
|
|
var artifacts []build.Artifact
|
|
|
|
for _, target := range targets {
|
|
built, err := b.buildTarget(ctx, cfg, target)
|
|
if err != nil {
|
|
return artifacts, coreerr.E("CPPBuilder.Build", "build failed", err)
|
|
}
|
|
artifacts = append(artifacts, built...)
|
|
}
|
|
|
|
return artifacts, nil
|
|
}
|
|
|
|
// buildTarget compiles for a single target platform.
|
|
func (b *CPPBuilder) buildTarget(ctx context.Context, cfg *build.Config, target build.Target) ([]build.Artifact, error) {
|
|
// Determine if this is a cross-compile or host build
|
|
isHostBuild := target.OS == runtime.GOOS && target.Arch == runtime.GOARCH
|
|
|
|
if isHostBuild {
|
|
return b.buildHost(ctx, cfg, target)
|
|
}
|
|
|
|
return b.buildCross(ctx, cfg, target)
|
|
}
|
|
|
|
// buildHost runs the standard make configure → make build → make package flow.
|
|
func (b *CPPBuilder) buildHost(ctx context.Context, cfg *build.Config, target build.Target) ([]build.Artifact, error) {
|
|
core.Print(nil, "Building C++ project for %s/%s (host)", target.OS, target.Arch)
|
|
|
|
// Step 1: Configure (runs conan install + cmake configure)
|
|
if err := b.runMake(ctx, cfg.ProjectDir, "configure"); err != nil {
|
|
return nil, coreerr.E("CPPBuilder.buildHost", "configure failed", err)
|
|
}
|
|
|
|
// Step 2: Build
|
|
if err := b.runMake(ctx, cfg.ProjectDir, "build"); err != nil {
|
|
return nil, coreerr.E("CPPBuilder.buildHost", "build failed", err)
|
|
}
|
|
|
|
// Step 3: Package
|
|
if err := b.runMake(ctx, cfg.ProjectDir, "package"); err != nil {
|
|
return nil, coreerr.E("CPPBuilder.buildHost", "package failed", err)
|
|
}
|
|
|
|
// Discover artifacts from build/packages/
|
|
return b.findArtifacts(cfg.FS, cfg.ProjectDir, target)
|
|
}
|
|
|
|
// buildCross runs a cross-compilation using a Conan profile name.
|
|
// The Makefile supports profile targets like: make gcc-linux-armv8
|
|
func (b *CPPBuilder) buildCross(ctx context.Context, cfg *build.Config, target build.Target) ([]build.Artifact, error) {
|
|
// Map target to a Conan profile name
|
|
profile := b.targetToProfile(target)
|
|
if profile == "" {
|
|
return nil, coreerr.E("CPPBuilder.buildCross", "no Conan profile mapped for target "+target.OS+"/"+target.Arch, nil)
|
|
}
|
|
|
|
core.Print(nil, "Building C++ project for %s/%s (cross: %s)", target.OS, target.Arch, profile)
|
|
|
|
// The Makefile exposes each profile as a top-level target
|
|
if err := b.runMake(ctx, cfg.ProjectDir, profile); err != nil {
|
|
return nil, coreerr.E("CPPBuilder.buildCross", "cross-compile for "+profile+" failed", err)
|
|
}
|
|
|
|
return b.findArtifacts(cfg.FS, cfg.ProjectDir, target)
|
|
}
|
|
|
|
// runMake executes a make target in the project directory.
|
|
func (b *CPPBuilder) runMake(ctx context.Context, projectDir string, target string) error {
|
|
if err := ax.ExecDir(ctx, projectDir, "make", target); err != nil {
|
|
return coreerr.E("CPPBuilder.runMake", "make "+target+" failed", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// findArtifacts searches for built packages in build/packages/.
|
|
func (b *CPPBuilder) findArtifacts(fs io.Medium, projectDir string, target build.Target) ([]build.Artifact, error) {
|
|
packagesDir := ax.Join(projectDir, "build", "packages")
|
|
|
|
if !fs.IsDir(packagesDir) {
|
|
// Fall back to searching build/release/src/ for raw binaries
|
|
return b.findBinaries(fs, projectDir, target)
|
|
}
|
|
|
|
entries, err := fs.List(packagesDir)
|
|
if err != nil {
|
|
return nil, coreerr.E("CPPBuilder.findArtifacts", "failed to list packages directory", err)
|
|
}
|
|
|
|
var artifacts []build.Artifact
|
|
for _, entry := range entries {
|
|
if entry.IsDir() {
|
|
continue
|
|
}
|
|
|
|
name := entry.Name()
|
|
// Skip checksum files and hidden files
|
|
if core.HasSuffix(name, ".sha256") || core.HasPrefix(name, ".") {
|
|
continue
|
|
}
|
|
|
|
artifacts = append(artifacts, build.Artifact{
|
|
Path: ax.Join(packagesDir, name),
|
|
OS: target.OS,
|
|
Arch: target.Arch,
|
|
})
|
|
}
|
|
|
|
return artifacts, nil
|
|
}
|
|
|
|
// findBinaries searches for compiled binaries in build/release/src/.
|
|
func (b *CPPBuilder) findBinaries(fs io.Medium, projectDir string, target build.Target) ([]build.Artifact, error) {
|
|
binDir := ax.Join(projectDir, "build", "release", "src")
|
|
|
|
if !fs.IsDir(binDir) {
|
|
return nil, coreerr.E("CPPBuilder.findBinaries", "no build output found in "+binDir, nil)
|
|
}
|
|
|
|
entries, err := fs.List(binDir)
|
|
if err != nil {
|
|
return nil, coreerr.E("CPPBuilder.findBinaries", "failed to list build directory", err)
|
|
}
|
|
|
|
var artifacts []build.Artifact
|
|
for _, entry := range entries {
|
|
if entry.IsDir() {
|
|
continue
|
|
}
|
|
|
|
name := entry.Name()
|
|
// Skip non-executable files (libraries, cmake files, etc.)
|
|
if core.HasSuffix(name, ".a") || core.HasSuffix(name, ".o") ||
|
|
core.HasSuffix(name, ".cmake") || core.HasPrefix(name, ".") {
|
|
continue
|
|
}
|
|
|
|
fullPath := ax.Join(binDir, name)
|
|
|
|
// On Unix, check if file is executable
|
|
if target.OS != "windows" {
|
|
info, err := fs.Stat(fullPath)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if info.Mode()&0111 == 0 {
|
|
continue
|
|
}
|
|
}
|
|
|
|
artifacts = append(artifacts, build.Artifact{
|
|
Path: fullPath,
|
|
OS: target.OS,
|
|
Arch: target.Arch,
|
|
})
|
|
}
|
|
|
|
return artifacts, nil
|
|
}
|
|
|
|
// targetToProfile maps a build target to a Conan cross-compilation profile name.
|
|
// Profile names match those in .core/build/cmake/profiles/.
|
|
func (b *CPPBuilder) targetToProfile(target build.Target) string {
|
|
key := target.OS + "/" + target.Arch
|
|
profiles := map[string]string{
|
|
"linux/amd64": "gcc-linux-x86_64",
|
|
"linux/x86_64": "gcc-linux-x86_64",
|
|
"linux/arm64": "gcc-linux-armv8",
|
|
"linux/armv8": "gcc-linux-armv8",
|
|
"darwin/arm64": "apple-clang-armv8",
|
|
"darwin/armv8": "apple-clang-armv8",
|
|
"darwin/amd64": "apple-clang-x86_64",
|
|
"darwin/x86_64": "apple-clang-x86_64",
|
|
"windows/amd64": "msvc-194-x86_64",
|
|
"windows/x86_64": "msvc-194-x86_64",
|
|
}
|
|
|
|
return profiles[key]
|
|
}
|
|
|
|
// validateMake checks if make is available.
|
|
func (b *CPPBuilder) validateMake() error {
|
|
if _, err := ax.LookPath("make"); err != nil {
|
|
return coreerr.E("CPPBuilder.validateMake", "make not found. Install build-essential (Linux) or Xcode Command Line Tools (macOS)", nil)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Ensure CPPBuilder implements the Builder interface.
|
|
var _ build.Builder = (*CPPBuilder)(nil)
|