use std::path::{Path, PathBuf};
use std::time::Instant;
use anyhow::{bail, Context, Result};
use crate::builder::archive::{
get_unified_include_path, ArchiveBuilder, ARCHIVE_DIR_OBJ, ARCHIVE_DIR_SHARED,
ARCHIVE_DIR_STATIC, ARCHIVE_DIR_SYMBOLS,
};
use crate::builder::cmake::{BuildType, CMakeConfig};
#[cfg(target_os = "linux")]
use crate::builder::toolchains::detect_default_compiler;
use crate::builder::toolchains::linux::{LinuxArch, LinuxToolchain};
use crate::builder::toolchains::Toolchain;
use crate::builder::{BuildContext, BuildResult, PlatformBuilder};
use crate::commands::build::LinkType;
pub struct LinuxBuilder;
impl LinuxBuilder {
pub fn new() -> Self {
Self
}
fn merge_module_static_libs(
&self,
build_dir: &Path,
lib_name: &str,
verbose: bool,
toolchain: &LinuxToolchain,
) -> Result<()> {
let out_dir = build_dir.join("out");
if verbose {
eprintln!(" [merge] Checking out directory: {}", out_dir.display());
}
if !out_dir.exists() {
if verbose {
eprintln!(" [merge] Out directory does not exist, skipping merge");
}
return Ok(());
}
let main_lib_name = format!("lib{}.a", lib_name);
let main_lib_path = out_dir.join(&main_lib_name);
if Self::reuse_merged_library(&out_dir, &main_lib_path, verbose)? {
return Ok(());
}
let mut module_libs = Self::module_libraries(&out_dir)?;
Self::report_module_libraries(&module_libs, verbose);
if module_libs.is_empty() {
if verbose {
eprintln!(" [merge] No libraries found, skipping merge");
}
return Ok(());
}
if module_libs.len() == 1
&& module_libs[0]
.file_name()
.is_some_and(|n| n == main_lib_name.as_str())
{
if verbose {
eprintln!(" [merge] Only main library exists, skipping merge");
}
return Ok(());
}
module_libs.retain(|p| p != &main_lib_path);
if verbose {
eprintln!(
" [merge] Module libraries to merge: {}",
module_libs.len()
);
for lib in &module_libs {
eprintln!(" - {}", lib.file_name().unwrap().to_string_lossy());
}
}
if module_libs.is_empty() {
if verbose {
eprintln!(" [merge] No module libraries after filtering, skipping merge");
}
return Ok(());
}
eprintln!(
" Merging {} module libraries into {}",
module_libs.len(),
main_lib_name
);
toolchain.merge_static_libs(&module_libs, &main_lib_path)?;
Self::remove_merged_modules(&module_libs, &main_lib_path, verbose);
Ok(())
}
fn report_module_libraries(module_libs: &[PathBuf], verbose: bool) {
if verbose {
eprintln!(" [merge] Found {} .a files:", module_libs.len());
for lib in module_libs {
eprintln!(" - {}", lib.file_name().unwrap().to_string_lossy());
}
}
}
fn remove_merged_modules(module_libs: &[PathBuf], main_lib_path: &Path, verbose: bool) {
eprintln!(" Cleaning up {} module libraries...", module_libs.len());
for lib in module_libs {
if lib != main_lib_path {
match std::fs::remove_file(lib) {
Ok(_) => {
if verbose {
eprintln!(
" ✓ Removed: {}",
lib.file_name().unwrap().to_string_lossy()
);
}
}
Err(e) => {
eprintln!(
" âš Failed to remove {}: {}",
lib.file_name().unwrap().to_string_lossy(),
e
);
}
}
}
}
}
fn module_libraries(out_dir: &Path) -> Result<Vec<PathBuf>> {
let mut module_libs: Vec<PathBuf> = Vec::new();
for entry in std::fs::read_dir(out_dir)? {
let entry = entry?;
let path = entry.path();
if path.is_file() {
if let Some(ext) = path.extension() {
if ext == "a" {
module_libs.push(path);
}
}
}
}
Ok(module_libs)
}
fn reuse_merged_library(out_dir: &Path, main_lib_path: &Path, verbose: bool) -> Result<bool> {
let main_lib_name = main_lib_path.file_name().unwrap().to_string_lossy();
if main_lib_path.exists() {
if let Ok(metadata) = std::fs::metadata(main_lib_path) {
if metadata.len() > 0 {
if verbose {
eprintln!(
" [merge] Main library {} already exists, skipping merge",
main_lib_name
);
}
for entry in std::fs::read_dir(out_dir)? {
let entry = entry?;
let path = entry.path();
if path.is_file() && path != main_lib_path {
if let Some(ext) = path.extension() {
if ext == "a" {
let _ = std::fs::remove_file(&path);
}
}
}
}
return Ok(true);
}
}
}
Ok(false)
}
fn merge_third_party_static_libs(
&self,
build_dir: &Path,
lib_name: &str,
verbose: bool,
toolchain: &LinuxToolchain,
) -> Result<()> {
let out_dir = build_dir.join("out");
let main_lib_path = out_dir.join(format!("lib{}.a", lib_name));
if !main_lib_path.exists() {
return Ok(());
}
let placeholder_name = format!("lib{}.a", lib_name);
let mut third_party_libs: Vec<PathBuf> = Vec::new();
for entry in std::fs::read_dir(build_dir)? {
let entry = entry?;
let path = entry.path();
if path.is_file() {
if let Some(ext) = path.extension() {
if ext == "a" {
let fname = path
.file_name()
.unwrap_or_default()
.to_str()
.unwrap_or_default();
if fname != placeholder_name {
third_party_libs.push(path);
}
}
}
}
}
if third_party_libs.is_empty() {
return Ok(());
}
if verbose {
eprintln!(
" Merging {} third-party libs into {}",
third_party_libs.len(),
placeholder_name
);
}
let mut all_libs = vec![main_lib_path.clone()];
all_libs.extend(third_party_libs);
toolchain.merge_static_libs(&all_libs, &main_lib_path)?;
Ok(())
}
fn build_link_type_for_arch(
&self,
ctx: &BuildContext,
link_type: &str,
arch: &str,
toolchain: &LinuxToolchain,
) -> Result<PathBuf> {
let build_dir = ctx.cmake_build_dir.join(link_type).join(arch);
let install_dir = build_dir.join("install");
let build_shared = link_type == "shared";
let mut cmake = CMakeConfig::new(ctx.project_root.clone(), build_dir.clone())
.build_type(if ctx.options.release {
BuildType::RelWithDebInfo
} else {
BuildType::Debug
})
.install_prefix(install_dir.clone())
.variable("CCGO_BUILD_STATIC", if build_shared { "OFF" } else { "ON" })
.variable("CCGO_BUILD_SHARED", if build_shared { "ON" } else { "OFF" })
.variable(
"CCGO_BUILD_SHARED_LIBS",
if build_shared { "ON" } else { "OFF" },
)
.variable("CCGO_LIB_NAME", ctx.lib_name())
.jobs(ctx.jobs())
.verbose(ctx.options.verbose);
cmake = Self::configure_project_options(cmake, ctx);
for (key, val) in toolchain.cmake_variables() {
cmake = cmake.variable(key, val);
}
let user = ctx.cmake_user_config("linux");
cmake = cmake
.user_arguments(user.arguments)
.user_c_flags(user.c_flags)
.user_cpp_flags(user.cpp_flags)
.user_cmake_files(ctx.cmake_user_files("linux"));
cmake.configure_build_install()?;
if !build_shared {
self.merge_module_static_libs(
&build_dir,
ctx.lib_name(),
ctx.options.verbose,
toolchain,
)?;
self.merge_third_party_static_libs(
&build_dir,
ctx.lib_name(),
ctx.options.verbose,
toolchain,
)?;
}
Ok(build_dir)
}
fn configure_project_options(mut cmake: CMakeConfig, ctx: &BuildContext) -> CMakeConfig {
if let Some(cmake_dir) = ctx.ccgo_cmake_dir() {
cmake = cmake.variable("CCGO_CMAKE_DIR", cmake_dir.display().to_string());
}
cmake = cmake.variable(
"CCGO_CONFIG_PRESET_VISIBILITY",
ctx.symbol_visibility().to_string(),
);
if let Some(deps_map) = ctx.deps_map() {
cmake = cmake.variable("CCGO_CONFIG_DEPS_MAP", deps_map);
}
if let Ok(feature_defines) = ctx.cmake_feature_defines() {
if !feature_defines.is_empty() {
cmake = cmake.feature_definitions(&feature_defines);
if ctx.options.verbose {
eprintln!(
" Enabled features: {}",
feature_defines.replace(';', ", ")
);
}
}
}
if let Some(cache) = ctx.compiler_cache() {
cmake = cmake.compiler_cache(cache);
}
cmake
}
pub fn generate_ide_project(&self, ctx: &BuildContext) -> Result<BuildResult> {
use std::process::Command;
let build_dir = ctx.cmake_build_dir.join("ide_project");
if build_dir.exists() {
std::fs::remove_dir_all(&build_dir)
.with_context(|| format!("Failed to clean {}", build_dir.display()))?;
}
std::fs::create_dir_all(&build_dir)
.with_context(|| format!("Failed to create {}", build_dir.display()))?;
eprintln!(
"Generating IDE project for Linux in {}...",
build_dir.display()
);
let mut cmake_cmd = Command::new("cmake");
cmake_cmd
.arg("-S")
.arg(&ctx.project_root)
.arg("-B")
.arg(&build_dir)
.arg("-G")
.arg("CodeLite - Unix Makefiles")
.arg("-DCMAKE_EXPORT_COMPILE_COMMANDS=ON");
if let Some(cmake_dir) = ctx.ccgo_cmake_dir() {
cmake_cmd.arg(format!("-DCCGO_CMAKE_DIR={}", cmake_dir.display()));
}
cmake_cmd.arg(format!("-DCCGO_LIB_NAME={}", ctx.lib_name()));
if ctx.options.verbose {
eprintln!("CMake configure: {:?}", cmake_cmd);
}
let status = cmake_cmd
.status()
.context("Failed to run CMake configure")?;
if !status.success() {
bail!("CMake configure failed");
}
Self::report_ide_files(ctx, &build_dir);
Ok(BuildResult {
sdk_archive: build_dir,
symbols_archive: None,
aar_archive: None,
duration_secs: 0.0,
architectures: vec![],
})
}
fn report_ide_files(ctx: &BuildContext, build_dir: &Path) {
let workspace_file = build_dir.join(format!("{}.workspace", ctx.lib_name()));
let compile_commands = build_dir.join("compile_commands.json");
if workspace_file.exists() {
eprintln!(
"\n✓ CodeLite workspace generated: {}",
workspace_file.display()
);
}
if compile_commands.exists() {
eprintln!(
"✓ compile_commands.json generated: {}",
compile_commands.display()
);
eprintln!(
" (Use with VS Code C/C++ extension, CLion, or other LSP-compatible editors)"
);
let root_compile_commands = ctx.project_root.join("compile_commands.json");
if !root_compile_commands.exists() {
#[cfg(unix)]
{
let _ = std::os::unix::fs::symlink(&compile_commands, &root_compile_commands);
eprintln!(" Symlinked to project root for VS Code");
}
}
}
if !workspace_file.exists() && !compile_commands.exists() {
eprintln!(
"\n✓ IDE project files generated in: {}",
build_dir.display()
);
}
}
fn collect_symbols(&self, lib_dir: &Path, symbols_temp: &Path, arch: &str) -> Result<bool> {
let mut found_symbols = false;
let obj_arch_dir = symbols_temp
.join(ARCHIVE_DIR_SYMBOLS)
.join(self.platform_name())
.join(ARCHIVE_DIR_OBJ)
.join(arch);
std::fs::create_dir_all(&obj_arch_dir)?;
for entry in std::fs::read_dir(lib_dir)? {
let entry = entry?;
let path = entry.path();
let name = entry.file_name();
let name = name.to_string_lossy();
if path.is_file() && (name.ends_with(".so") || name.contains(".so.")) {
let file_name = path.file_name().unwrap();
std::fs::copy(&path, obj_arch_dir.join(file_name))?;
found_symbols = true;
}
}
Ok(found_symbols)
}
fn build_arch(
&self,
ctx: &BuildContext,
arch: &str,
archive: &ArchiveBuilder,
symbols_temp: &Path,
) -> Result<bool> {
let mut found_symbols = false;
let linux_arch = LinuxArch::parse(arch)?;
let toolchain = LinuxToolchain::detect_for_arch(linux_arch)?;
if matches!(ctx.options.link_type, LinkType::Static | LinkType::All) {
if ctx.options.verbose {
eprintln!(" Building static library...");
}
let build_dir = self.build_link_type_for_arch(ctx, "static", arch, &toolchain)?;
if let Some(lib_dir) = self.find_lib_dir(&build_dir) {
let archive_path = format!(
"lib/{}/{}/{}",
self.platform_name(),
ARCHIVE_DIR_STATIC,
arch
);
archive.add_directory_filtered(&lib_dir, &archive_path, &["a"])?;
}
}
if matches!(ctx.options.link_type, LinkType::Shared | LinkType::All) {
if ctx.options.verbose {
eprintln!(" Building shared library...");
}
let build_dir = self.build_link_type_for_arch(ctx, "shared", arch, &toolchain)?;
if let Some(lib_dir) = self.find_lib_dir(&build_dir) {
let archive_path = format!(
"lib/{}/{}/{}",
self.platform_name(),
ARCHIVE_DIR_SHARED,
arch
);
archive.add_directory_filtered(&lib_dir, &archive_path, &["so", "a"])?;
found_symbols = self.collect_symbols(&lib_dir, symbols_temp, arch)?;
if ctx.options.release {
super::elf_symbols::strip_staged_shared_libraries(
&archive.staging_dir().join(&archive_path),
&toolchain.strip_path()?,
)?;
}
}
}
Ok(found_symbols)
}
fn add_include_files(ctx: &BuildContext, archive: &ArchiveBuilder) -> Result<()> {
let include_source = ctx.include_source_dir();
if include_source.exists() {
let include_path = get_unified_include_path(ctx.lib_name(), &include_source);
archive.add_directory(&include_source, &include_path)?;
if ctx.options.verbose {
eprintln!(
"Added include files from {} to {}",
include_source.display(),
include_path
);
}
}
Ok(())
}
fn finish_symbols_archive(
archive: &ArchiveBuilder,
symbols_temp: &Path,
found_symbols: bool,
) -> Result<Option<PathBuf>> {
let mut symbols_archive_result = None;
if found_symbols {
let symbols_archive_path = archive.create_symbols_archive(symbols_temp)?;
symbols_archive_result = Some(symbols_archive_path);
}
if symbols_temp.exists() {
std::fs::remove_dir_all(symbols_temp).ok();
}
Ok(symbols_archive_result)
}
fn find_lib_dir(&self, build_dir: &Path) -> Option<PathBuf> {
let possible_dirs = vec![
build_dir.join("out"), build_dir.join("install/lib"), build_dir.join("lib"),
];
possible_dirs.into_iter().find(|dir| dir.exists())
}
}
fn resolve_arches(ctx: &BuildContext) -> Vec<String> {
if ctx.options.architectures.is_empty() {
vec!["x86_64".to_string(), "aarch64".to_string()]
} else {
ctx.options.architectures.clone()
}
}
impl PlatformBuilder for LinuxBuilder {
fn platform_name(&self) -> &str {
"linux"
}
fn default_architectures(&self) -> Vec<String> {
vec!["x86_64".to_string(), "aarch64".to_string()]
}
fn validate_prerequisites(&self, _ctx: &BuildContext) -> Result<()> {
#[cfg(not(target_os = "linux"))]
{
bail!(
"Linux builds can only be run on Linux systems.\n\
Current OS: {}\n\n\
To build for Linux from your current OS, use Docker:\n \
ccgo build linux --docker",
std::env::consts::OS
);
}
#[cfg(target_os = "linux")]
{
if !crate::builder::cmake::is_cmake_available() {
bail!("CMake is required for Linux builds. Please install CMake.");
}
let compiler = detect_default_compiler()
.context("No C/C++ compiler found. Please install GCC or Clang.")?;
if _ctx.options.verbose {
eprintln!(
"Using {} compiler: {} ({})",
compiler.compiler_type,
compiler.cxx.display(),
compiler.version
);
}
let arches = resolve_arches(_ctx);
if arches.iter().any(|a| a == "aarch64") {
LinuxToolchain::detect_for_arch(LinuxArch::Aarch64)
.context("aarch64 cross-compiler unavailable")?;
}
Ok(())
}
}
fn build(&self, ctx: &BuildContext) -> Result<BuildResult> {
if ctx.options.ide_project {
return self.generate_ide_project(ctx);
}
let start = Instant::now();
self.validate_prerequisites(ctx)?;
if ctx.options.verbose {
eprintln!("Building {} for Linux...", ctx.lib_name());
}
ctx.materialize_source_deps(self.platform_name())?;
std::fs::create_dir_all(&ctx.output_dir)?;
let archive = ArchiveBuilder::new(
ctx.lib_name(),
ctx.version(),
ctx.publish_suffix(),
ctx.options.release,
"linux",
ctx.output_dir.clone(),
)?;
let arches = resolve_arches(ctx);
let link_type_str = ctx.options.link_type.to_string();
let symbols_temp = std::env::temp_dir().join(format!("ccgo-symbols-{}", ctx.lib_name()));
let mut found_symbols = false;
for arch in &arches {
if ctx.options.verbose {
eprintln!("Building for arch: {}", arch);
}
if self.build_arch(ctx, arch, &archive, &symbols_temp)? {
found_symbols = true;
}
}
Self::add_include_files(ctx, &archive)?;
let sdk_archive = archive.create_sdk_archive(&arches, &link_type_str)?;
let symbols_archive_result =
Self::finish_symbols_archive(&archive, &symbols_temp, found_symbols)?;
let duration = start.elapsed();
if ctx.options.verbose {
eprintln!(
"Linux build completed in {:.2}s: {}",
duration.as_secs_f64(),
sdk_archive.display()
);
if let Some(ref sym) = symbols_archive_result {
eprintln!(" Symbols archive: {}", sym.display());
}
}
Ok(BuildResult {
sdk_archive,
symbols_archive: symbols_archive_result,
aar_archive: None,
duration_secs: duration.as_secs_f64(),
architectures: arches,
})
}
fn clean(&self, ctx: &BuildContext) -> Result<()> {
crate::utils::paths::clean_ccgo_build_platform(&ctx.ccgo_build_root, "linux")?;
for old_dir in &[
ctx.project_root.join("cmake_build/Linux"),
ctx.project_root.join("cmake_build/linux"),
] {
if old_dir.exists() {
std::fs::remove_dir_all(old_dir)
.with_context(|| format!("Failed to clean {}", old_dir.display()))?;
}
}
for old_dir in &[
ctx.project_root.join("target/release/linux"),
ctx.project_root.join("target/debug/linux"),
ctx.project_root.join("target/release/Linux"),
ctx.project_root.join("target/debug/Linux"),
ctx.project_root.join("target/linux"),
ctx.project_root.join("target/Linux"),
] {
if old_dir.exists() {
std::fs::remove_dir_all(old_dir)
.with_context(|| format!("Failed to clean {}", old_dir.display()))?;
}
}
Ok(())
}
}
impl Default for LinuxBuilder {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn symbols_archive_nests_unstripped_libraries_under_platform() {
let root = tempfile::tempdir().unwrap();
let libraries = root.path().join("out");
std::fs::create_dir(&libraries).unwrap();
std::fs::write(libraries.join("libdemo.so"), b"unstripped library").unwrap();
std::fs::write(libraries.join("libdemo.a"), b"static library").unwrap();
let staging = root.path().join("symbols-staging");
assert!(LinuxBuilder::new()
.collect_symbols(&libraries, &staging, "x86_64")
.unwrap());
let archive = ArchiveBuilder::new(
"demo",
"1.2.3",
"",
true,
"linux",
root.path().join("archives"),
)
.unwrap();
let path = archive.create_symbols_archive(&staging).unwrap();
let mut zip = zip::ZipArchive::new(std::fs::File::open(path).unwrap()).unwrap();
let mut bytes = Vec::new();
use std::io::Read;
zip.by_name("symbols/linux/obj/x86_64/libdemo.so")
.unwrap()
.read_to_end(&mut bytes)
.unwrap();
assert_eq!(bytes, b"unstripped library");
assert!(!zip
.file_names()
.any(|name| name.starts_with("obj/") || name.ends_with(".a")));
}
}