mirror of
https://github.com/dexoron/dcr.git
synced 2026-10-22 01:29:37 +00:00
refactor: modularize build core engine, update workspaces, cache, and test suite
This commit is contained in:
126
src/core/build/builder/artifact.rs
Normal file
126
src/core/build/builder/artifact.rs
Normal file
@@ -0,0 +1,126 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::common;
|
||||
use crate::platform;
|
||||
use crate::utils::build::is_bare_metal_target;
|
||||
use std::process::Command;
|
||||
use std::time::Instant;
|
||||
|
||||
pub(crate) fn archive_static(
|
||||
ctx: &BuildContext,
|
||||
objects: &[String],
|
||||
start_time: Instant,
|
||||
) -> Result<f64, String> {
|
||||
let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
|
||||
if !common::needs_link(objects, &lib_path) {
|
||||
return Ok(common::elapsed_secs(start_time));
|
||||
}
|
||||
|
||||
let archiver = ctx.archiver.unwrap_or(if cfg!(target_os = "windows") {
|
||||
"lib"
|
||||
} else {
|
||||
"ar"
|
||||
});
|
||||
|
||||
let mut cmd = Command::new(archiver);
|
||||
if cfg!(target_os = "windows") && archiver == "lib" {
|
||||
cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
|
||||
} else {
|
||||
cmd.arg("rcs").arg(&lib_path);
|
||||
}
|
||||
for obj in objects {
|
||||
cmd.arg(obj);
|
||||
}
|
||||
run(ctx, cmd, start_time)
|
||||
}
|
||||
|
||||
pub(crate) fn link_binary(
|
||||
ctx: &BuildContext,
|
||||
objects: &[String],
|
||||
default_linker: &str,
|
||||
start_time: Instant,
|
||||
) -> Result<f64, String> {
|
||||
let mut cmd = Command::new(ctx.linker.unwrap_or(default_linker));
|
||||
if ctx.kind == "sharedlib" {
|
||||
if cfg!(target_os = "macos") {
|
||||
cmd.arg("-dynamiclib");
|
||||
} else {
|
||||
cmd.arg("-shared");
|
||||
}
|
||||
}
|
||||
if ctx.kind == "efi" {
|
||||
cmd.arg("-shared");
|
||||
cmd.arg("-nostdlib");
|
||||
cmd.arg("-Wl,-dll");
|
||||
cmd.arg("-Wl,--subsystem,10");
|
||||
} else if ctx.freestanding || is_bare_metal_target(ctx.target) {
|
||||
cmd.arg("-nostdlib");
|
||||
cmd.arg("-static");
|
||||
}
|
||||
for obj in objects {
|
||||
cmd.arg(obj);
|
||||
}
|
||||
for dir in ctx.lib_dirs {
|
||||
cmd.arg(format!("-L{dir}"));
|
||||
}
|
||||
for lib in ctx.libs {
|
||||
cmd.arg(format!("-l{lib}"));
|
||||
}
|
||||
for flag in ctx.ldflags {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
|
||||
let name = ctx.output_filename.unwrap_or(ctx.project_name);
|
||||
let ext = ctx.output_extension.unwrap_or("");
|
||||
let final_name = if ext.is_empty() {
|
||||
name.to_string()
|
||||
} else {
|
||||
format!("{}.{}", name, ext)
|
||||
};
|
||||
|
||||
let out_path = if ctx.kind == "sharedlib" {
|
||||
platform::shared_lib_path(ctx.profile, &final_name, ctx.target_dir)
|
||||
} else if ctx.kind == "efi" {
|
||||
platform::efi_path(ctx.profile, &final_name, ctx.target_dir)
|
||||
} else if ctx.kind == "elf" {
|
||||
platform::elf_path(ctx.profile, &final_name, ctx.target_dir)
|
||||
} else {
|
||||
platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
|
||||
};
|
||||
|
||||
if !common::needs_link(objects, &out_path) {
|
||||
return Ok(common::elapsed_secs(start_time));
|
||||
}
|
||||
cmd.arg("-o").arg(out_path);
|
||||
run(ctx, cmd, start_time)
|
||||
}
|
||||
|
||||
fn run(ctx: &BuildContext, mut cmd: Command, start_time: Instant) -> Result<f64, String> {
|
||||
if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
|
||||
eprintln!("[dcr] {:?}", cmd);
|
||||
}
|
||||
let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?;
|
||||
if output.status.success() {
|
||||
Ok(common::elapsed_secs(start_time))
|
||||
} else {
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||||
Err(format!("Build failed:\nstdout: {stdout}\nstderr: {stderr}"))
|
||||
}
|
||||
}
|
||||
209
src/core/build/builder/cc_common.rs
Normal file
209
src/core/build/builder/cc_common.rs
Normal file
@@ -0,0 +1,209 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::builder::artifact;
|
||||
use crate::core::build::common;
|
||||
use crate::utils::build::is_bare_metal_target;
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
use std::time::Instant;
|
||||
|
||||
pub fn build(ctx: &BuildContext) -> Result<f64, String> {
|
||||
let compiler = if ctx.compiler.is_empty() {
|
||||
"cc"
|
||||
} else {
|
||||
ctx.compiler
|
||||
};
|
||||
let start_time = Instant::now();
|
||||
let obj_dir = match ctx.target_dir {
|
||||
Some(dir) => Path::new(dir).join("obj"),
|
||||
None => Path::new("./target").join(ctx.profile).join("obj"),
|
||||
};
|
||||
let qt_include_path = if ctx.qt {
|
||||
crate::core::build::language::cxx::qt::process_qt(ctx, &obj_dir)?
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
let mut all_source_roots = ctx.source_roots.to_vec();
|
||||
if let Some(qt_path) = &qt_include_path {
|
||||
all_source_roots.push(qt_path.clone());
|
||||
}
|
||||
|
||||
let extensions = source_extensions(ctx.language);
|
||||
let sources = common::collect_sources(
|
||||
&all_source_roots,
|
||||
&extensions,
|
||||
ctx.exclude_dirs,
|
||||
ctx.include_paths,
|
||||
)?;
|
||||
let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o", qt_include_path)?;
|
||||
|
||||
if ctx.kind == "staticlib" {
|
||||
return artifact::archive_static(ctx, &objects, start_time);
|
||||
}
|
||||
|
||||
artifact::link_binary(ctx, &objects, compiler, start_time)
|
||||
}
|
||||
|
||||
pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
let extensions = source_extensions(ctx.language);
|
||||
common::collect_sources(
|
||||
ctx.source_roots,
|
||||
&extensions,
|
||||
ctx.exclude_dirs,
|
||||
ctx.include_paths,
|
||||
)
|
||||
}
|
||||
|
||||
fn source_extensions(language: &str) -> Vec<&'static str> {
|
||||
crate::core::build::common::source_extensions(language)
|
||||
}
|
||||
|
||||
fn default_flags(profile: &str) -> &'static [&'static str] {
|
||||
crate::utils::build::default_profile_flags(profile)
|
||||
}
|
||||
|
||||
fn build_objects(
|
||||
compiler: &str,
|
||||
sources: &[String],
|
||||
obj_dir: &Path,
|
||||
ctx: &BuildContext,
|
||||
obj_ext: &str,
|
||||
qt_include_dir: Option<PathBuf>,
|
||||
) -> Result<Vec<String>, String> {
|
||||
let objects: Vec<String> = sources
|
||||
.iter()
|
||||
.map(|s| common::object_path(obj_dir, s, obj_ext))
|
||||
.collect();
|
||||
|
||||
common::parallel_build(
|
||||
sources.len(),
|
||||
|i| {
|
||||
build_object(
|
||||
compiler,
|
||||
&sources[i],
|
||||
&objects[i],
|
||||
ctx,
|
||||
qt_include_dir.as_deref(),
|
||||
)
|
||||
},
|
||||
ctx.codegen_units,
|
||||
)?;
|
||||
|
||||
Ok(objects)
|
||||
}
|
||||
|
||||
fn build_object(
|
||||
compiler: &str,
|
||||
source: &str,
|
||||
obj_path: &str,
|
||||
ctx: &BuildContext,
|
||||
qt_include_dir: Option<&Path>,
|
||||
) -> Result<(), String> {
|
||||
if let Some(parent) = Path::new(obj_path).parent() {
|
||||
fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
|
||||
}
|
||||
|
||||
if !common::needs_rebuild(source, obj_path) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let mut cmd = Command::new(compiler);
|
||||
cmd.arg("-c");
|
||||
|
||||
if let Some(flag) = asm_lang_flag(source) {
|
||||
cmd.arg("-x").arg(flag);
|
||||
}
|
||||
|
||||
cmd.arg(source).arg("-o").arg(obj_path);
|
||||
|
||||
if ctx.kind == "sharedlib" {
|
||||
cmd.arg("-fPIC");
|
||||
}
|
||||
|
||||
if (ctx.freestanding || is_bare_metal_target(ctx.target))
|
||||
&& ctx.language.to_lowercase() != "asm"
|
||||
{
|
||||
cmd.arg("-ffreestanding");
|
||||
}
|
||||
|
||||
if ctx.panic_abort && ctx.language.to_lowercase() != "asm" {
|
||||
if ctx.language.contains("++")
|
||||
|| ctx.language.contains("cpp")
|
||||
|| ctx.language.contains("cxx")
|
||||
{
|
||||
cmd.arg("-fno-exceptions");
|
||||
}
|
||||
cmd.arg("-fno-unwind-tables");
|
||||
cmd.arg("-fno-asynchronous-unwind-tables");
|
||||
}
|
||||
|
||||
if let Some(platform) = ctx.platform
|
||||
&& !platform.trim().is_empty()
|
||||
{
|
||||
cmd.arg(format!("-march={}", platform));
|
||||
}
|
||||
|
||||
if !ctx.standard.is_empty() && ctx.language.to_lowercase() != "asm" {
|
||||
let ext = Path::new(source)
|
||||
.extension()
|
||||
.and_then(|e| e.to_str())
|
||||
.unwrap_or("");
|
||||
let is_cpp = matches!(ext, "cpp" | "cxx" | "cc");
|
||||
if is_cpp && !ctx.cxx_standard.is_empty() {
|
||||
cmd.arg(format!("-std={}", ctx.cxx_standard));
|
||||
} else if !is_cpp {
|
||||
cmd.arg(format!("-std={}", ctx.standard));
|
||||
}
|
||||
}
|
||||
|
||||
let use_dcr_defaults =
|
||||
ctx.cflags.is_empty() && !(ctx.freestanding || is_bare_metal_target(ctx.target));
|
||||
if use_dcr_defaults {
|
||||
for flag in default_flags(ctx.profile) {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
}
|
||||
|
||||
for flag in ctx.cflags {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
|
||||
for dir in ctx.include_dirs {
|
||||
cmd.arg(format!("-I{dir}"));
|
||||
}
|
||||
|
||||
if let Some(path) = qt_include_dir {
|
||||
cmd.arg(format!("-I{}", path.display()));
|
||||
}
|
||||
|
||||
let d_path = Path::new(obj_path).with_extension("d");
|
||||
cmd.arg("-MMD").arg("-MF").arg(&d_path);
|
||||
|
||||
if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
|
||||
eprintln!("[dcr] {:?}", cmd);
|
||||
}
|
||||
|
||||
common::run_command_sync_output(&mut cmd)
|
||||
}
|
||||
|
||||
fn asm_lang_flag(source: &str) -> Option<&'static str> {
|
||||
crate::core::build::common::asm_lang_flag(source)
|
||||
}
|
||||
234
src/core/build/builder/mod.rs
Normal file
234
src/core/build/builder/mod.rs
Normal file
@@ -0,0 +1,234 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
pub mod artifact;
|
||||
pub mod cc_common;
|
||||
pub mod msvc;
|
||||
|
||||
use crate::core::build::language::asm::{fasm, gas, masm, nasm};
|
||||
use crate::core::build::language::llvm_ir;
|
||||
|
||||
pub struct BuildContext<'a> {
|
||||
pub profile: &'a str,
|
||||
pub project_name: &'a str,
|
||||
pub compiler: &'a str,
|
||||
pub language: &'a str,
|
||||
pub standard: &'a str,
|
||||
pub cxx_standard: &'a str,
|
||||
pub target: Option<&'a str>,
|
||||
pub target_dir: Option<&'a str>,
|
||||
pub kind: &'a str,
|
||||
pub platform: Option<&'a str>,
|
||||
pub linker: Option<&'a str>,
|
||||
pub archiver: Option<&'a str>,
|
||||
pub moc: Option<&'a str>,
|
||||
pub uic: Option<&'a str>,
|
||||
pub rcc: Option<&'a str>,
|
||||
pub package_type: Option<&'a str>,
|
||||
pub freestanding: bool,
|
||||
pub panic_abort: bool,
|
||||
pub codegen_units: usize,
|
||||
pub source_roots: &'a [std::path::PathBuf],
|
||||
pub exclude_dirs: &'a [std::path::PathBuf],
|
||||
pub include_paths: &'a [String],
|
||||
pub include_dirs: &'a [String],
|
||||
pub lib_dirs: &'a [String],
|
||||
pub libs: &'a [String],
|
||||
pub cflags: &'a [String],
|
||||
pub ldflags: &'a [String],
|
||||
pub output_filename: Option<&'a str>,
|
||||
pub output_extension: Option<&'a str>,
|
||||
pub verbose: bool,
|
||||
pub qt: bool,
|
||||
}
|
||||
|
||||
pub trait Builder {
|
||||
#[allow(dead_code)]
|
||||
fn id(&self) -> &'static str;
|
||||
fn build(&self, ctx: &BuildContext) -> Result<f64, String>;
|
||||
fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String>;
|
||||
}
|
||||
|
||||
struct Cc;
|
||||
struct Msvc;
|
||||
struct Nasm;
|
||||
struct Gas;
|
||||
struct Masm;
|
||||
struct Fasm;
|
||||
struct Llc;
|
||||
|
||||
impl Builder for Cc {
|
||||
fn id(&self) -> &'static str {
|
||||
"cc"
|
||||
}
|
||||
fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
|
||||
cc_common::build(ctx)
|
||||
}
|
||||
fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
cc_common::collect_sources(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
impl Builder for Msvc {
|
||||
fn id(&self) -> &'static str {
|
||||
"msvc"
|
||||
}
|
||||
fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
|
||||
msvc::build(ctx)
|
||||
}
|
||||
fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
msvc::collect_sources(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
impl Builder for Nasm {
|
||||
fn id(&self) -> &'static str {
|
||||
"nasm"
|
||||
}
|
||||
fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
|
||||
nasm::build(ctx)
|
||||
}
|
||||
fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
nasm::collect_sources(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
impl Builder for Gas {
|
||||
fn id(&self) -> &'static str {
|
||||
"gas"
|
||||
}
|
||||
fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
|
||||
gas::build(ctx)
|
||||
}
|
||||
fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
gas::collect_sources(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
impl Builder for Masm {
|
||||
fn id(&self) -> &'static str {
|
||||
"masm"
|
||||
}
|
||||
fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
|
||||
masm::build(ctx)
|
||||
}
|
||||
fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
masm::collect_sources(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
impl Builder for Fasm {
|
||||
fn id(&self) -> &'static str {
|
||||
"fasm"
|
||||
}
|
||||
fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
|
||||
fasm::build(ctx)
|
||||
}
|
||||
fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
fasm::collect_sources(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
impl Builder for Llc {
|
||||
fn id(&self) -> &'static str {
|
||||
"llvm_ir"
|
||||
}
|
||||
fn build(&self, ctx: &BuildContext) -> Result<f64, String> {
|
||||
llvm_ir::build(ctx)
|
||||
}
|
||||
fn collect_sources(&self, ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
llvm_ir::collect_sources(ctx)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn builder_for(compiler: &str) -> &'static dyn Builder {
|
||||
let c = compiler.to_lowercase();
|
||||
if c.contains("clang-cl") {
|
||||
return &Msvc;
|
||||
}
|
||||
if c == "as" || c.contains("gas") {
|
||||
return &Gas;
|
||||
}
|
||||
if c.contains("llc") {
|
||||
return &Llc;
|
||||
}
|
||||
if c.contains("fasm") {
|
||||
return &Fasm;
|
||||
}
|
||||
if c.contains("nasm") {
|
||||
return &Nasm;
|
||||
}
|
||||
if c == "ml" || c == "ml64" || c.contains("masm") {
|
||||
return &Masm;
|
||||
}
|
||||
if c == "cl" || c.contains("msvc") {
|
||||
return &Msvc;
|
||||
}
|
||||
&Cc
|
||||
}
|
||||
|
||||
pub fn build(ctx: &BuildContext) -> Result<f64, String> {
|
||||
if !check_compiler_exists(ctx.compiler) {
|
||||
return Err(format!(
|
||||
"Compiler not found: {}. Make sure it is installed and available in PATH.",
|
||||
ctx.compiler
|
||||
));
|
||||
}
|
||||
builder_for(ctx.compiler).build(ctx)
|
||||
}
|
||||
|
||||
fn check_compiler_exists(compiler: &str) -> bool {
|
||||
let name = if compiler.is_empty() {
|
||||
"cc"
|
||||
} else {
|
||||
match compiler.to_lowercase().as_str() {
|
||||
"gas" | "gnu-as" => "as",
|
||||
"nasm" => "nasm",
|
||||
"fasm" | "fasm64" => "fasm",
|
||||
"masm" | "ml" | "ml64" => "ml",
|
||||
_ => compiler,
|
||||
}
|
||||
};
|
||||
std::process::Command::new(name)
|
||||
.arg("--version")
|
||||
.output()
|
||||
.is_ok()
|
||||
}
|
||||
|
||||
pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
builder_for(ctx.compiler).collect_sources(ctx)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn builder_resolves_by_compiler_name() {
|
||||
assert_eq!(builder_for("gcc").id(), "cc");
|
||||
assert_eq!(builder_for("clang").id(), "cc");
|
||||
assert_eq!(builder_for("clang++").id(), "cc");
|
||||
assert_eq!(builder_for("").id(), "cc");
|
||||
assert_eq!(builder_for("nasm").id(), "nasm");
|
||||
assert_eq!(builder_for("as").id(), "gas");
|
||||
assert_eq!(builder_for("llc-18").id(), "llvm_ir");
|
||||
assert_eq!(builder_for("fasm").id(), "fasm");
|
||||
assert_eq!(builder_for("ml64").id(), "masm");
|
||||
assert_eq!(builder_for("cl").id(), "msvc");
|
||||
assert_eq!(builder_for("clang-cl").id(), "msvc");
|
||||
}
|
||||
}
|
||||
343
src/core/build/builder/msvc/mod.rs
Normal file
343
src/core/build/builder/msvc/mod.rs
Normal file
@@ -0,0 +1,343 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::common;
|
||||
use crate::platform;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
use std::time::Instant;
|
||||
|
||||
pub fn build(ctx: &BuildContext) -> Result<f64, String> {
|
||||
let compiler = if ctx.compiler.is_empty() {
|
||||
"cl"
|
||||
} else {
|
||||
ctx.compiler
|
||||
};
|
||||
let lang = ctx.language.to_lowercase();
|
||||
if lang.contains("asm") {
|
||||
return Err("MSVC backend does not support build.language with asm".to_string());
|
||||
}
|
||||
let start_time = Instant::now();
|
||||
let sources = collect_sources(ctx)?;
|
||||
let obj_dir = match ctx.target_dir {
|
||||
Some(dir) => Path::new(dir).join("obj"),
|
||||
None => Path::new("./target").join(ctx.profile).join("obj"),
|
||||
};
|
||||
let objects = build_objects(compiler, &sources, &obj_dir, ctx, "obj")?;
|
||||
|
||||
if ctx.kind == "staticlib" {
|
||||
let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
|
||||
if !common::needs_link(&objects, &lib_path) {
|
||||
let elapsed = common::elapsed_secs(start_time);
|
||||
return Ok(elapsed);
|
||||
}
|
||||
let mut cmd = Command::new(ctx.archiver.unwrap_or("lib"));
|
||||
cmd.arg("/nologo").arg(format!("/OUT:{lib_path}"));
|
||||
for obj in &objects {
|
||||
cmd.arg(obj);
|
||||
}
|
||||
if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
|
||||
eprintln!("[dcr] {:?}", cmd);
|
||||
}
|
||||
match cmd.status() {
|
||||
Ok(status) if status.success() => {
|
||||
let elapsed = common::elapsed_secs(start_time);
|
||||
return Ok(elapsed);
|
||||
}
|
||||
Ok(_) => return Err("Build failed".to_string()),
|
||||
Err(err) => return Err(format!("Build failed: {err}")),
|
||||
}
|
||||
}
|
||||
|
||||
let mut cmd = Command::new(compiler);
|
||||
cmd.arg("/nologo");
|
||||
if ctx.kind == "sharedlib" {
|
||||
cmd.arg("/LD");
|
||||
}
|
||||
match ctx.language.to_lowercase().as_str() {
|
||||
"c" => {
|
||||
cmd.arg("/TC");
|
||||
}
|
||||
"c++" | "cpp" | "cxx" => {
|
||||
cmd.arg("/TP");
|
||||
}
|
||||
_ => {
|
||||
return Err("Unsupported language".to_string());
|
||||
}
|
||||
}
|
||||
|
||||
if !ctx.standard.is_empty() {
|
||||
let std_flag = msvc_standard_flag(ctx.language, ctx.standard)?;
|
||||
cmd.arg(std_flag);
|
||||
}
|
||||
|
||||
for obj in &objects {
|
||||
cmd.arg(obj);
|
||||
}
|
||||
if ctx.cflags.is_empty() {
|
||||
for flag in default_flags(ctx.profile) {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
}
|
||||
for flag in ctx.cflags {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
for dir in ctx.lib_dirs {
|
||||
cmd.arg(format!("/LIBPATH:{dir}"));
|
||||
}
|
||||
for lib in ctx.libs {
|
||||
if lib.to_lowercase().ends_with(".lib") {
|
||||
cmd.arg(lib);
|
||||
} else {
|
||||
cmd.arg(format!("{lib}.lib"));
|
||||
}
|
||||
}
|
||||
if !ctx.ldflags.is_empty() {
|
||||
cmd.arg("/link");
|
||||
for flag in ctx.ldflags {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
}
|
||||
let out_path = if ctx.kind == "sharedlib" {
|
||||
platform::shared_lib_path(ctx.profile, ctx.project_name, ctx.target_dir)
|
||||
} else if ctx.kind == "elf" {
|
||||
platform::elf_path(ctx.profile, ctx.project_name, ctx.target_dir)
|
||||
} else {
|
||||
platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
|
||||
};
|
||||
|
||||
if !common::needs_link(&objects, &out_path) {
|
||||
let elapsed = common::elapsed_secs(start_time);
|
||||
return Ok(elapsed);
|
||||
}
|
||||
cmd.arg("-o").arg(out_path);
|
||||
|
||||
if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
|
||||
eprintln!("[dcr] {:?}", cmd);
|
||||
}
|
||||
match cmd.status() {
|
||||
Ok(status) if status.success() => {
|
||||
let elapsed = common::elapsed_secs(start_time);
|
||||
Ok(elapsed)
|
||||
}
|
||||
Ok(_) => Err("Build failed".to_string()),
|
||||
Err(err) => Err(format!("Build failed: {err}")),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
let extensions = source_extensions(ctx.language);
|
||||
common::collect_sources(
|
||||
ctx.source_roots,
|
||||
&extensions,
|
||||
ctx.exclude_dirs,
|
||||
ctx.include_paths,
|
||||
)
|
||||
}
|
||||
|
||||
fn source_extensions(language: &str) -> Vec<&'static str> {
|
||||
crate::core::build::common::source_extensions(language)
|
||||
}
|
||||
|
||||
fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String> {
|
||||
let lang = language.to_lowercase();
|
||||
let std = standard.to_lowercase();
|
||||
if lang == "c" {
|
||||
return match std.as_str() {
|
||||
"c11" => Ok("/std:c11".to_string()),
|
||||
"c17" => Ok("/std:c17".to_string()),
|
||||
_ => Err("Unsupported C standard for MSVC".to_string()),
|
||||
};
|
||||
}
|
||||
if lang == "c++" || lang == "cpp" || lang == "cxx" {
|
||||
return match std.as_str() {
|
||||
"c++11" => Ok("/std:c++11".to_string()),
|
||||
"c++14" => Ok("/std:c++14".to_string()),
|
||||
"c++17" => Ok("/std:c++17".to_string()),
|
||||
"c++20" => Ok("/std:c++20".to_string()),
|
||||
"c++23" => Ok("/std:c++latest".to_string()),
|
||||
_ => Err("Unsupported C++ standard for MSVC".to_string()),
|
||||
};
|
||||
}
|
||||
Err("Unsupported language".to_string())
|
||||
}
|
||||
|
||||
fn msvc_arch_flag(platform: Option<&str>) -> Option<&'static str> {
|
||||
let raw = platform?.trim();
|
||||
if raw.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let p = raw.to_lowercase().replace('-', "_");
|
||||
if p == "x86" || (p.starts_with('i') && p.ends_with("86") && p.len() == 4) {
|
||||
return Some("/arch:IA32");
|
||||
}
|
||||
match p.as_str() {
|
||||
"sse2" => Some("/arch:SSE2"),
|
||||
"avx" => Some("/arch:AVX"),
|
||||
"avx2" => Some("/arch:AVX2"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn default_flags(profile: &str) -> &'static [&'static str] {
|
||||
match profile {
|
||||
"release" => &["/O2", "/DNDEBUG"],
|
||||
"debug" => &["/Od", "/Zi", "/W4", "/DDCR_DEBUG", "/Oy-"],
|
||||
_ => &[],
|
||||
}
|
||||
}
|
||||
|
||||
fn build_objects(
|
||||
compiler: &str,
|
||||
sources: &[String],
|
||||
obj_dir: &Path,
|
||||
ctx: &BuildContext,
|
||||
obj_ext: &str,
|
||||
) -> Result<Vec<String>, String> {
|
||||
let objects: Vec<String> = sources
|
||||
.iter()
|
||||
.map(|s| common::object_path(obj_dir, s, obj_ext))
|
||||
.collect();
|
||||
|
||||
common::parallel_build(
|
||||
sources.len(),
|
||||
|i| build_object(compiler, &sources[i], &objects[i], ctx),
|
||||
ctx.codegen_units,
|
||||
)?;
|
||||
|
||||
Ok(objects)
|
||||
}
|
||||
|
||||
fn build_object(
|
||||
compiler: &str,
|
||||
source: &str,
|
||||
obj_path: &str,
|
||||
ctx: &BuildContext,
|
||||
) -> Result<(), String> {
|
||||
if let Some(parent) = Path::new(obj_path).parent() {
|
||||
fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
|
||||
}
|
||||
|
||||
if !common::needs_rebuild(source, obj_path) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let mut cmd = Command::new(compiler);
|
||||
cmd.arg("/nologo");
|
||||
|
||||
let ext = Path::new(source)
|
||||
.extension()
|
||||
.and_then(|e| e.to_str())
|
||||
.unwrap_or("");
|
||||
let is_cpp = matches!(ext, "cpp" | "cxx" | "cc");
|
||||
if is_cpp {
|
||||
cmd.arg("/TP");
|
||||
} else {
|
||||
cmd.arg("/TC");
|
||||
}
|
||||
|
||||
let std_val = if is_cpp && !ctx.cxx_standard.is_empty() {
|
||||
ctx.cxx_standard
|
||||
} else if !is_cpp && !ctx.standard.is_empty() {
|
||||
ctx.standard
|
||||
} else {
|
||||
""
|
||||
};
|
||||
if !std_val.is_empty() {
|
||||
let std_flag = msvc_standard_flag(if is_cpp { "c++" } else { "c" }, std_val)?;
|
||||
cmd.arg(std_flag);
|
||||
}
|
||||
|
||||
if let Some(flag) = msvc_arch_flag(ctx.platform) {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
|
||||
if ctx.cflags.is_empty() {
|
||||
for flag in default_flags(ctx.profile) {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
}
|
||||
|
||||
for flag in ctx.cflags {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
|
||||
for dir in ctx.include_dirs {
|
||||
cmd.arg(format!("/I{dir}"));
|
||||
}
|
||||
|
||||
cmd.arg("/c").arg(source).arg(format!("/Fo:{}", obj_path));
|
||||
cmd.arg("/showIncludes");
|
||||
|
||||
if std::env::var("DCR_DEBUG").is_ok() {
|
||||
eprintln!("[dcr] {:?}", cmd);
|
||||
}
|
||||
|
||||
let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?;
|
||||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
|
||||
let mut headers = Vec::new();
|
||||
let mut clean_stdout = String::new();
|
||||
|
||||
for line in stdout.lines() {
|
||||
if let Some(stripped) = line.strip_prefix("Note: including file:") {
|
||||
headers.push(stripped.trim().to_string());
|
||||
} else if let Some(stripped) = line.strip_prefix("Примечание: включение файла:")
|
||||
{
|
||||
headers.push(stripped.trim().to_string());
|
||||
} else {
|
||||
clean_stdout.push_str(line);
|
||||
clean_stdout.push('\n');
|
||||
}
|
||||
}
|
||||
|
||||
let _lock = common::get_output_lock().lock().unwrap();
|
||||
|
||||
if !output.status.success() {
|
||||
eprint!("{}", clean_stdout);
|
||||
eprint!("{}", stderr);
|
||||
return Err("Build failed".to_string());
|
||||
}
|
||||
|
||||
let trimmed_out = clean_stdout.trim();
|
||||
let trimmed_err = stderr.trim();
|
||||
let src_filename = Path::new(source)
|
||||
.file_name()
|
||||
.and_then(|v| v.to_str())
|
||||
.unwrap_or("");
|
||||
|
||||
if !trimmed_out.is_empty() && trimmed_out != src_filename {
|
||||
print!("{}", clean_stdout);
|
||||
}
|
||||
|
||||
if !trimmed_err.is_empty() {
|
||||
eprintln!("{}", trimmed_err);
|
||||
}
|
||||
|
||||
let d_path = Path::new(obj_path).with_extension("d");
|
||||
let mut d_content = format!("{}: \\\n", obj_path.replace('\\', "/"));
|
||||
for h in headers {
|
||||
let escaped = h.replace('\\', "/").replace(" ", "\\ ");
|
||||
d_content.push_str(&format!(" {} \\\n", escaped));
|
||||
}
|
||||
fs::write(&d_path, d_content).map_err(|err| format!("d file error: {err}"))?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
254
src/core/build/cache.rs
Normal file
254
src/core/build/cache.rs
Normal file
@@ -0,0 +1,254 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::common;
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
pub(crate) fn compute_build_fingerprint(
|
||||
ctx: &BuildContext,
|
||||
sources: &[String],
|
||||
headers: &[PathBuf],
|
||||
lib_files: &[PathBuf],
|
||||
) -> Result<String, String> {
|
||||
let mut hasher = Sha256::new();
|
||||
hasher.update(ctx.profile.as_bytes());
|
||||
hasher.update(ctx.project_name.as_bytes());
|
||||
hasher.update(ctx.compiler.as_bytes());
|
||||
hasher.update(ctx.language.as_bytes());
|
||||
hasher.update(ctx.standard.as_bytes());
|
||||
hasher.update(ctx.kind.as_bytes());
|
||||
if let Some(v) = ctx.target_dir {
|
||||
hasher.update(v.as_bytes());
|
||||
}
|
||||
if let Some(v) = ctx.platform {
|
||||
hasher.update(v.as_bytes());
|
||||
}
|
||||
if let Some(v) = ctx.linker {
|
||||
hasher.update(v.as_bytes());
|
||||
}
|
||||
if let Some(v) = ctx.archiver {
|
||||
hasher.update(v.as_bytes());
|
||||
}
|
||||
for value in ctx.include_dirs {
|
||||
hasher.update(value.as_bytes());
|
||||
}
|
||||
for value in ctx.lib_dirs {
|
||||
hasher.update(value.as_bytes());
|
||||
}
|
||||
for value in ctx.libs {
|
||||
hasher.update(value.as_bytes());
|
||||
}
|
||||
for value in ctx.cflags {
|
||||
hasher.update(value.as_bytes());
|
||||
}
|
||||
for value in ctx.ldflags {
|
||||
hasher.update(value.as_bytes());
|
||||
}
|
||||
let toml =
|
||||
fs::read_to_string("dcr.toml").map_err(|err| format!("Failed to read dcr.toml: {err}"))?;
|
||||
hasher.update(toml.as_bytes());
|
||||
if let Ok(lock) = fs::read_to_string("dcr.lock") {
|
||||
hasher.update(lock.as_bytes());
|
||||
}
|
||||
for source in sources {
|
||||
let path = Path::new(source);
|
||||
update_hasher_with_file(&mut hasher, path)?;
|
||||
}
|
||||
for header in headers {
|
||||
update_hasher_with_file(&mut hasher, header)?;
|
||||
}
|
||||
for lib in lib_files {
|
||||
update_hasher_with_file(&mut hasher, lib)?;
|
||||
}
|
||||
Ok(to_hex(&hasher.finalize()))
|
||||
}
|
||||
|
||||
pub(crate) fn should_skip_build(ctx: &BuildContext, fingerprint: &str) -> bool {
|
||||
let output = build_output_path(ctx);
|
||||
if !Path::new(&output).is_file() {
|
||||
return false;
|
||||
}
|
||||
let cache_path = build_cache_path(ctx.profile, ctx.target_dir);
|
||||
let cached = fs::read_to_string(cache_path).unwrap_or_default();
|
||||
cached.trim() == fingerprint
|
||||
}
|
||||
|
||||
pub(crate) fn write_build_fingerprint(ctx: &BuildContext, fingerprint: &str) -> Result<(), String> {
|
||||
let cache_path = build_cache_path(ctx.profile, ctx.target_dir);
|
||||
if let Some(parent) = cache_path.parent() {
|
||||
fs::create_dir_all(parent).map_err(|err| format!("Failed to create cache dir: {err}"))?;
|
||||
}
|
||||
fs::write(cache_path, format!("{fingerprint}\n"))
|
||||
.map_err(|err| format!("Failed to write cache: {err}"))
|
||||
}
|
||||
|
||||
fn build_cache_path(profile: &str, target_dir: Option<&str>) -> PathBuf {
|
||||
match target_dir {
|
||||
Some(dir) => Path::new(dir).join(".dcr-build.hash"),
|
||||
None => Path::new("./target").join(profile).join(".dcr-build.hash"),
|
||||
}
|
||||
}
|
||||
|
||||
fn build_output_path(ctx: &BuildContext) -> String {
|
||||
let name = ctx.output_filename.unwrap_or(ctx.project_name);
|
||||
let ext = ctx.output_extension.unwrap_or("");
|
||||
|
||||
let final_name = if ext.is_empty() {
|
||||
name.to_string()
|
||||
} else {
|
||||
format!("{}.{}", name, ext)
|
||||
};
|
||||
|
||||
if ctx.kind == "staticlib" {
|
||||
return crate::platform::lib_path(ctx.profile, &final_name, ctx.target_dir);
|
||||
}
|
||||
if ctx.kind == "sharedlib" {
|
||||
return crate::platform::shared_lib_path(ctx.profile, &final_name, ctx.target_dir);
|
||||
}
|
||||
if ctx.kind == "efi" {
|
||||
return crate::platform::efi_path(ctx.profile, &final_name, ctx.target_dir);
|
||||
}
|
||||
if ctx.kind == "elf" {
|
||||
return crate::platform::elf_path(ctx.profile, &final_name, ctx.target_dir);
|
||||
}
|
||||
crate::platform::bin_path(ctx.profile, &final_name, ctx.target_dir)
|
||||
}
|
||||
|
||||
pub(crate) fn collect_header_files(
|
||||
ctx: &BuildContext,
|
||||
project_root: &Path,
|
||||
) -> Result<Vec<PathBuf>, String> {
|
||||
let mut out = Vec::new();
|
||||
let mut roots = Vec::new();
|
||||
if ctx.source_roots.is_empty() {
|
||||
roots.push(project_root.join("src"));
|
||||
} else {
|
||||
roots.extend(ctx.source_roots.iter().cloned());
|
||||
}
|
||||
let abs_root = project_root
|
||||
.canonicalize()
|
||||
.unwrap_or_else(|_| project_root.to_path_buf());
|
||||
for dir in ctx.include_dirs {
|
||||
let p = Path::new(dir).to_path_buf();
|
||||
if let Ok(abs_p) = p.canonicalize() {
|
||||
if abs_p.starts_with(&abs_root) {
|
||||
roots.push(abs_p);
|
||||
}
|
||||
} else if p.starts_with(&abs_root) {
|
||||
roots.push(p);
|
||||
}
|
||||
}
|
||||
for root in roots {
|
||||
if !root.exists() {
|
||||
continue;
|
||||
}
|
||||
collect_header_files_rec(&root, &mut out, ctx.exclude_dirs, ctx.include_paths)?;
|
||||
}
|
||||
out.sort();
|
||||
out.dedup();
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn collect_header_files_rec(
|
||||
dir: &Path,
|
||||
out: &mut Vec<PathBuf>,
|
||||
exclude_dirs: &[PathBuf],
|
||||
include_paths: &[String],
|
||||
) -> Result<(), String> {
|
||||
if common::is_excluded(dir, exclude_dirs, include_paths) && include_paths.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
for entry in fs::read_dir(dir).map_err(|err| format!("read_dir error: {err}"))? {
|
||||
let entry = entry.map_err(|err| format!("read_dir error: {err}"))?;
|
||||
let path = entry.path();
|
||||
if path.is_dir() {
|
||||
if common::is_excluded(&path, exclude_dirs, include_paths) && include_paths.is_empty() {
|
||||
continue;
|
||||
}
|
||||
collect_header_files_rec(&path, out, exclude_dirs, include_paths)?;
|
||||
continue;
|
||||
}
|
||||
if !path.is_file() {
|
||||
continue;
|
||||
}
|
||||
if common::is_excluded(&path, exclude_dirs, include_paths) {
|
||||
continue;
|
||||
}
|
||||
if is_header_file(&path) {
|
||||
out.push(path);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn is_header_file(path: &Path) -> bool {
|
||||
let ext = path.extension().and_then(|v| v.to_str()).unwrap_or("");
|
||||
matches!(ext, "h" | "hpp" | "hh" | "hxx" | "inc")
|
||||
}
|
||||
|
||||
pub(crate) fn collect_lib_files(ctx: &BuildContext) -> Vec<PathBuf> {
|
||||
let mut out = Vec::new();
|
||||
for dir in ctx.lib_dirs {
|
||||
let dir_path = Path::new(dir);
|
||||
for lib in ctx.libs {
|
||||
for candidate in lib_candidates(lib) {
|
||||
let path = dir_path.join(candidate);
|
||||
if path.is_file() {
|
||||
out.push(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn lib_candidates(name: &str) -> Vec<String> {
|
||||
if cfg!(target_os = "windows") {
|
||||
return vec![format!("{name}.lib")];
|
||||
}
|
||||
if cfg!(target_os = "macos") {
|
||||
return vec![
|
||||
format!("lib{name}.a"),
|
||||
format!("lib{name}.dylib"),
|
||||
format!("lib{name}.so"),
|
||||
];
|
||||
}
|
||||
vec![
|
||||
format!("lib{name}.a"),
|
||||
format!("lib{name}.so"),
|
||||
format!("lib{name}.so.0"),
|
||||
]
|
||||
}
|
||||
|
||||
fn update_hasher_with_file(hasher: &mut Sha256, path: &Path) -> Result<(), String> {
|
||||
hasher.update(path.to_string_lossy().as_bytes());
|
||||
let meta = fs::metadata(path).map_err(|err| format!("source read error: {err}"))?;
|
||||
hasher.update(meta.len().to_le_bytes());
|
||||
if let Ok(modified) = meta.modified()
|
||||
&& let Ok(duration) = modified.duration_since(std::time::UNIX_EPOCH)
|
||||
{
|
||||
hasher.update(duration.as_nanos().to_le_bytes());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn to_hex(bytes: &[u8]) -> String {
|
||||
crate::utils::fs::to_hex(bytes)
|
||||
}
|
||||
866
src/core/build/common.rs
Normal file
866
src/core/build/common.rs
Normal file
@@ -0,0 +1,866 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
use std::sync::{Mutex, OnceLock};
|
||||
use std::time::Instant;
|
||||
|
||||
static OUTPUT_MUTEX: OnceLock<Mutex<()>> = OnceLock::new();
|
||||
|
||||
pub fn get_output_lock() -> &'static Mutex<()> {
|
||||
OUTPUT_MUTEX.get_or_init(|| Mutex::new(()))
|
||||
}
|
||||
|
||||
pub fn collect_sources(
|
||||
roots: &[PathBuf],
|
||||
extensions: &[&str],
|
||||
exclude_dirs: &[PathBuf],
|
||||
include_paths: &[String],
|
||||
) -> Result<Vec<String>, String> {
|
||||
let mut sources = Vec::new();
|
||||
for root in roots {
|
||||
collect_sources_rec(root, extensions, &mut sources, exclude_dirs, include_paths)?;
|
||||
}
|
||||
sources.sort();
|
||||
Ok(sources)
|
||||
}
|
||||
|
||||
fn collect_sources_rec(
|
||||
dir: &Path,
|
||||
extensions: &[&str],
|
||||
out: &mut Vec<String>,
|
||||
exclude_dirs: &[PathBuf],
|
||||
include_paths: &[String],
|
||||
) -> Result<(), String> {
|
||||
let full_dir = if dir.is_absolute() {
|
||||
dir.to_path_buf()
|
||||
} else {
|
||||
std::env::current_dir()
|
||||
.map_err(|err| format!("src dir error: {err}"))?
|
||||
.join(dir)
|
||||
};
|
||||
if is_excluded(&full_dir, exclude_dirs, include_paths) && include_paths.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let entries = fs::read_dir(&full_dir)
|
||||
.map_err(|err| format!("src dir error for {:?}: {err}", full_dir))?;
|
||||
for entry in entries {
|
||||
let entry = entry.map_err(|err| format!("src dir error for {:?}: {err}", full_dir))?;
|
||||
let path = entry.path();
|
||||
if path.is_dir() {
|
||||
if is_excluded(&path, exclude_dirs, include_paths) && include_paths.is_empty() {
|
||||
continue;
|
||||
}
|
||||
collect_sources_rec(&path, extensions, out, exclude_dirs, include_paths)?;
|
||||
continue;
|
||||
}
|
||||
if !path.is_file() {
|
||||
continue;
|
||||
}
|
||||
if is_excluded(&path, exclude_dirs, include_paths) {
|
||||
continue;
|
||||
}
|
||||
let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or("");
|
||||
let ext_lower = ext_raw.to_lowercase();
|
||||
let matched = extensions
|
||||
.iter()
|
||||
.any(|allowed| *allowed == ext_raw || *allowed == ext_lower);
|
||||
if matched {
|
||||
out.push(normalize_source_path(&path));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn is_excluded(path: &Path, exclude_dirs: &[PathBuf], include_paths: &[String]) -> bool {
|
||||
if matches_patterns(path, include_paths, true) {
|
||||
return false;
|
||||
}
|
||||
if matches_patterns(path, include_paths, false) {
|
||||
return true;
|
||||
}
|
||||
exclude_dirs.iter().any(|dir| path.starts_with(dir))
|
||||
}
|
||||
|
||||
fn matches_patterns(path: &Path, patterns: &[String], positive: bool) -> bool {
|
||||
if patterns.is_empty() {
|
||||
return false;
|
||||
}
|
||||
let cwd = std::env::current_dir().ok();
|
||||
let abs_path = if path.is_absolute() {
|
||||
path.to_path_buf()
|
||||
} else if let Some(base) = cwd.as_ref() {
|
||||
base.join(path)
|
||||
} else {
|
||||
path.to_path_buf()
|
||||
};
|
||||
let abs = abs_path.to_string_lossy().replace('\\', "/");
|
||||
let rel = cwd
|
||||
.as_ref()
|
||||
.and_then(|base| abs_path.strip_prefix(base).ok())
|
||||
.map(|p| p.to_string_lossy().replace('\\', "/"))
|
||||
.unwrap_or_default();
|
||||
let rel_dot = if rel.is_empty() {
|
||||
String::new()
|
||||
} else {
|
||||
format!("./{rel}")
|
||||
};
|
||||
for raw in patterns {
|
||||
let trimmed = raw.trim();
|
||||
if trimmed.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let is_neg = trimmed.starts_with('!');
|
||||
if is_neg == positive {
|
||||
continue;
|
||||
}
|
||||
let normalized = trimmed.trim_start_matches('!').replace('\\', "/");
|
||||
if normalized.is_empty() {
|
||||
continue;
|
||||
}
|
||||
if has_glob_magic(&normalized) {
|
||||
let pat = match glob::Pattern::new(&normalized) {
|
||||
Ok(p) => p,
|
||||
Err(_) => continue,
|
||||
};
|
||||
if pat.matches(&abs)
|
||||
|| (!rel.is_empty() && (pat.matches(&rel) || pat.matches(&rel_dot)))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
let norm = normalized.trim_end_matches('/');
|
||||
let candidate = Path::new(norm);
|
||||
let full = if candidate.is_absolute() {
|
||||
candidate.to_path_buf()
|
||||
} else if let Some(base) = cwd.as_ref() {
|
||||
base.join(candidate)
|
||||
} else {
|
||||
candidate.to_path_buf()
|
||||
};
|
||||
if abs_path.starts_with(&full) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
pub fn has_glob_magic(value: &str) -> bool {
|
||||
value.chars().any(|c| matches!(c, '*' | '?' | '['))
|
||||
}
|
||||
|
||||
pub fn asm_lang_flag(source: &str) -> Option<&'static str> {
|
||||
let ext = Path::new(source).extension().and_then(|v| v.to_str())?;
|
||||
match ext {
|
||||
"S" => Some("assembler-with-cpp"),
|
||||
"s" | "asm" => Some("assembler"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn source_extensions(language: &str) -> Vec<&'static str> {
|
||||
let mut out = Vec::new();
|
||||
for part in language.split(',').map(|s| s.trim()) {
|
||||
if let Some(lang) = crate::core::build::language::language_for_token(part) {
|
||||
out.extend(lang.extensions().iter().copied());
|
||||
}
|
||||
}
|
||||
if out.is_empty() {
|
||||
out.extend(["c"]);
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub fn elapsed_secs(start: Instant) -> f64 {
|
||||
((start.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0
|
||||
}
|
||||
|
||||
pub fn parallel_build<F>(total_tasks: usize, task_fn: F, max_jobs: usize) -> Result<(), String>
|
||||
where
|
||||
F: Fn(usize) -> Result<(), String> + Sync + Send,
|
||||
{
|
||||
let available = std::thread::available_parallelism()
|
||||
.map(|n| n.get())
|
||||
.unwrap_or(1);
|
||||
let num_threads = if max_jobs > 0 {
|
||||
max_jobs.min(available)
|
||||
} else {
|
||||
available
|
||||
};
|
||||
|
||||
let counter = std::sync::atomic::AtomicUsize::new(0);
|
||||
let err_msg = std::sync::Mutex::new(None);
|
||||
|
||||
std::thread::scope(|s| {
|
||||
for _ in 0..num_threads {
|
||||
s.spawn(|| {
|
||||
loop {
|
||||
if err_msg.lock().unwrap().is_some() {
|
||||
break;
|
||||
}
|
||||
|
||||
let i = counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
|
||||
if i >= total_tasks {
|
||||
break;
|
||||
}
|
||||
|
||||
if let Err(e) = task_fn(i) {
|
||||
let mut err = err_msg.lock().unwrap();
|
||||
if err.is_none() {
|
||||
*err = Some(e);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
if let Some(err) = err_msg.into_inner().unwrap() {
|
||||
return Err(err);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn run_command_sync_output(cmd: &mut Command) -> Result<(), String> {
|
||||
let output = cmd.output().map_err(|err| format!("Build failed: {err}"))?;
|
||||
let _guard = OUTPUT_MUTEX.get_or_init(|| Mutex::new(())).lock().unwrap();
|
||||
if !output.stdout.is_empty() {
|
||||
print!("{}", String::from_utf8_lossy(&output.stdout));
|
||||
}
|
||||
if !output.stderr.is_empty() {
|
||||
eprint!("{}", String::from_utf8_lossy(&output.stderr));
|
||||
}
|
||||
if output.status.success() {
|
||||
Ok(())
|
||||
} else {
|
||||
Err("Build failed".to_string())
|
||||
}
|
||||
}
|
||||
|
||||
pub fn normalize_source_path(path: &Path) -> String {
|
||||
if !path.is_absolute() {
|
||||
return path.to_string_lossy().to_string();
|
||||
}
|
||||
if let Ok(base) = std::env::current_dir()
|
||||
&& let Ok(rel) = path.strip_prefix(&base)
|
||||
{
|
||||
return format!("./{}", rel.to_string_lossy());
|
||||
}
|
||||
path.to_string_lossy().to_string()
|
||||
}
|
||||
|
||||
pub fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
|
||||
let src_path = Path::new(source);
|
||||
let stripped = src_path.strip_prefix("./").unwrap_or(src_path);
|
||||
let rel = stripped
|
||||
.components()
|
||||
.skip(1)
|
||||
.collect::<std::path::PathBuf>();
|
||||
let rel = if rel.components().next().is_some() {
|
||||
rel
|
||||
} else {
|
||||
stripped.to_path_buf()
|
||||
};
|
||||
let mut out = obj_dir.join(rel);
|
||||
let ext = out
|
||||
.extension()
|
||||
.and_then(|e| e.to_str())
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
let obj_ext = obj_ext.trim_start_matches('.');
|
||||
if !ext.is_empty() {
|
||||
let stem = out
|
||||
.file_stem()
|
||||
.and_then(|s| s.to_str())
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
out.set_file_name(format!("{stem}.{ext}.{obj_ext}"));
|
||||
} else {
|
||||
out.set_extension(obj_ext);
|
||||
}
|
||||
out.to_string_lossy().to_string()
|
||||
}
|
||||
|
||||
pub fn needs_rebuild(source: &str, object: &str) -> bool {
|
||||
let src_time = fs::metadata(source).and_then(|m| m.modified());
|
||||
let obj_time = fs::metadata(object).and_then(|m| m.modified());
|
||||
let o_time = match obj_time {
|
||||
Ok(t) => t,
|
||||
Err(_) => return true,
|
||||
};
|
||||
match src_time {
|
||||
Ok(s) if s > o_time => return true,
|
||||
Err(_) => return true,
|
||||
_ => {}
|
||||
}
|
||||
|
||||
let d_file = PathBuf::from(object).with_extension("d");
|
||||
if let Ok(content) = fs::read_to_string(&d_file) {
|
||||
let deps = parse_d_file(&content);
|
||||
for dep in deps {
|
||||
let dep_path = Path::new(&dep);
|
||||
if dep_path == Path::new(object) || dep_path == Path::new(source) {
|
||||
continue;
|
||||
}
|
||||
if let Ok(dep_meta) = fs::metadata(dep_path) {
|
||||
if let Ok(dep_time) = dep_meta.modified()
|
||||
&& dep_time > o_time
|
||||
{
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
pub fn needs_link(objects: &[String], output_path: &str) -> bool {
|
||||
let out_meta = match fs::metadata(output_path) {
|
||||
Ok(m) => m,
|
||||
Err(_) => return true,
|
||||
};
|
||||
let out_time = match out_meta.modified() {
|
||||
Ok(t) => t,
|
||||
Err(_) => return true,
|
||||
};
|
||||
for obj in objects {
|
||||
let obj_meta = match fs::metadata(obj) {
|
||||
Ok(m) => m,
|
||||
Err(_) => return true,
|
||||
};
|
||||
let obj_time = match obj_meta.modified() {
|
||||
Ok(t) => t,
|
||||
Err(_) => return true,
|
||||
};
|
||||
if obj_time > out_time {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
fn parse_d_file(content: &str) -> Vec<String> {
|
||||
let mut deps = Vec::new();
|
||||
let mut target_end = 0;
|
||||
let bytes = content.as_bytes();
|
||||
for (i, &b) in bytes.iter().enumerate() {
|
||||
if b == b':' {
|
||||
if i == 1
|
||||
&& bytes[0].is_ascii_alphabetic()
|
||||
&& i + 1 < bytes.len()
|
||||
&& (bytes[i + 1] == b'\\' || bytes[i + 1] == b'/')
|
||||
{
|
||||
continue;
|
||||
}
|
||||
target_end = i + 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let deps_str = if target_end > 0 {
|
||||
&content[target_end..]
|
||||
} else {
|
||||
content
|
||||
};
|
||||
|
||||
let mut current_path = String::new();
|
||||
let mut in_escape = false;
|
||||
let mut chars = deps_str.chars().peekable();
|
||||
|
||||
while let Some(c) = chars.next() {
|
||||
if in_escape {
|
||||
if c == '\n' {
|
||||
} else if c == '\r' {
|
||||
if chars.peek() == Some(&'\n') {
|
||||
chars.next();
|
||||
}
|
||||
} else {
|
||||
current_path.push(c);
|
||||
}
|
||||
in_escape = false;
|
||||
} else if c == '\\' {
|
||||
in_escape = true;
|
||||
} else if c.is_whitespace() {
|
||||
if !current_path.is_empty() {
|
||||
deps.push(current_path.clone());
|
||||
current_path.clear();
|
||||
}
|
||||
} else {
|
||||
current_path.push(c);
|
||||
}
|
||||
}
|
||||
if !current_path.is_empty() {
|
||||
deps.push(current_path);
|
||||
}
|
||||
deps
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::fs;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Mutex;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
static TEST_COUNTER: AtomicUsize = AtomicUsize::new(0);
|
||||
static CWD_LOCK: Mutex<()> = Mutex::new(());
|
||||
|
||||
fn temp_dir(prefix: &str) -> PathBuf {
|
||||
let n = TEST_COUNTER.fetch_add(1, Ordering::SeqCst);
|
||||
let dir = std::env::temp_dir().join(format!("dcr_test_{prefix}_{n}"));
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
fn default_roots() -> Vec<PathBuf> {
|
||||
vec![PathBuf::from("src")]
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn object_path_basic() {
|
||||
let obj_dir = Path::new("target/debug/obj");
|
||||
let result = object_path(obj_dir, "./src/main.c", "o");
|
||||
assert_eq!(result, "target/debug/obj/main.c.o");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn object_path_nested() {
|
||||
let obj_dir = Path::new("target/debug/obj");
|
||||
let result = object_path(obj_dir, "./src/core/utils.c", "o");
|
||||
assert_eq!(result, "target/debug/obj/core/utils.c.o");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn object_path_no_prefix() {
|
||||
let obj_dir = Path::new("target/debug/obj");
|
||||
let result = object_path(obj_dir, "src/main.c", "o");
|
||||
assert_eq!(result, "target/debug/obj/main.c.o");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn object_path_msvc_ext() {
|
||||
let obj_dir = Path::new("target/debug/obj");
|
||||
let result = object_path(obj_dir, "./src/main.c", "obj");
|
||||
assert_eq!(result, "target/debug/obj/main.c.obj");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn needs_link_no_output() {
|
||||
let dir = temp_dir("link_no_out");
|
||||
let obj1 = dir.join("test1.o");
|
||||
let obj2 = dir.join("test2.o");
|
||||
let out = dir.join("app");
|
||||
fs::write(&obj1, "").unwrap();
|
||||
fs::write(&obj2, "").unwrap();
|
||||
let objs = vec![
|
||||
obj1.to_string_lossy().to_string(),
|
||||
obj2.to_string_lossy().to_string(),
|
||||
];
|
||||
assert!(needs_link(&objs, &out.to_string_lossy()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn needs_link_fresh() {
|
||||
let dir = temp_dir("link_fresh");
|
||||
let obj1 = dir.join("test1.o");
|
||||
let obj2 = dir.join("test2.o");
|
||||
let out = dir.join("app");
|
||||
fs::write(&obj1, "").unwrap();
|
||||
fs::write(&obj2, "").unwrap();
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
fs::write(&out, "").unwrap();
|
||||
let objs = vec![
|
||||
obj1.to_string_lossy().to_string(),
|
||||
obj2.to_string_lossy().to_string(),
|
||||
];
|
||||
assert!(!needs_link(&objs, &out.to_string_lossy()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn needs_link_stale() {
|
||||
let dir = temp_dir("link_stale");
|
||||
let obj1 = dir.join("test1.o");
|
||||
let obj2 = dir.join("test2.o");
|
||||
let out = dir.join("app");
|
||||
fs::write(&obj1, "").unwrap();
|
||||
fs::write(&out, "").unwrap();
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
fs::write(&obj2, "").unwrap();
|
||||
let objs = vec![
|
||||
obj1.to_string_lossy().to_string(),
|
||||
obj2.to_string_lossy().to_string(),
|
||||
];
|
||||
assert!(needs_link(&objs, &out.to_string_lossy()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn needs_rebuild_no_object() {
|
||||
let dir = temp_dir("rebuild_no_obj");
|
||||
let src = dir.join("test.c");
|
||||
fs::write(&src, "int main() {}").unwrap();
|
||||
let obj = dir.join("test.o");
|
||||
assert!(needs_rebuild(
|
||||
&src.to_string_lossy(),
|
||||
&obj.to_string_lossy()
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn needs_rebuild_fresh() {
|
||||
let dir = temp_dir("rebuild_fresh");
|
||||
let src = dir.join("test.c");
|
||||
let obj = dir.join("test.o");
|
||||
fs::write(&src, "int main() {}").unwrap();
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
fs::write(&obj, "").unwrap();
|
||||
assert!(!needs_rebuild(
|
||||
&src.to_string_lossy(),
|
||||
&obj.to_string_lossy()
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn needs_rebuild_stale() {
|
||||
let dir = temp_dir("rebuild_stale");
|
||||
let src = dir.join("test.c");
|
||||
let obj = dir.join("test.o");
|
||||
fs::write(&obj, "").unwrap();
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
fs::write(&src, "int main() { return 1; }").unwrap();
|
||||
assert!(needs_rebuild(
|
||||
&src.to_string_lossy(),
|
||||
&obj.to_string_lossy()
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn is_excluded_match() {
|
||||
let include: Vec<String> = Vec::new();
|
||||
let excluded = vec![PathBuf::from("/project/src/vendor")];
|
||||
assert!(is_excluded(
|
||||
Path::new("/project/src/vendor"),
|
||||
&excluded,
|
||||
&include
|
||||
));
|
||||
assert!(is_excluded(
|
||||
Path::new("/project/src/vendor/lib.c"),
|
||||
&excluded,
|
||||
&include
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn is_excluded_no_match() {
|
||||
let include: Vec<String> = Vec::new();
|
||||
let excluded = vec![PathBuf::from("/project/src/vendor")];
|
||||
assert!(!is_excluded(
|
||||
Path::new("/project/src/main.c"),
|
||||
&excluded,
|
||||
&include
|
||||
));
|
||||
assert!(!is_excluded(
|
||||
Path::new("/other/vendor"),
|
||||
&excluded,
|
||||
&include
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn collect_sources_c_files() {
|
||||
let dir = temp_dir("collect_c");
|
||||
let src = dir.join("src");
|
||||
fs::create_dir_all(&src).unwrap();
|
||||
fs::write(src.join("main.c"), "").unwrap();
|
||||
fs::write(src.join("utils.c"), "").unwrap();
|
||||
fs::write(src.join("README.md"), "").unwrap(); // should be ignored
|
||||
|
||||
let _guard = CWD_LOCK.lock().unwrap();
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let include: Vec<String> = Vec::new();
|
||||
let roots = default_roots();
|
||||
let result = collect_sources(&roots, &["c"], &[], &include);
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
|
||||
let sources = result.expect("should find sources");
|
||||
assert_eq!(sources.len(), 2);
|
||||
assert!(sources.iter().any(|s| s.ends_with("main.c")));
|
||||
assert!(sources.iter().any(|s| s.ends_with("utils.c")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn collect_sources_cpp_files() {
|
||||
let dir = temp_dir("collect_cpp");
|
||||
let src = dir.join("src");
|
||||
fs::create_dir_all(&src).unwrap();
|
||||
fs::write(src.join("main.cpp"), "").unwrap();
|
||||
fs::write(src.join("helper.cxx"), "").unwrap();
|
||||
fs::write(src.join("other.cc"), "").unwrap();
|
||||
fs::write(src.join("skip.c"), "").unwrap(); // should be ignored
|
||||
|
||||
let _guard = CWD_LOCK.lock().unwrap();
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let include: Vec<String> = Vec::new();
|
||||
let roots = default_roots();
|
||||
let result = collect_sources(&roots, &["cpp", "cxx", "cc"], &[], &include);
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
|
||||
let sources = result.expect("should find sources");
|
||||
assert_eq!(sources.len(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn collect_sources_empty_dir() {
|
||||
let dir = temp_dir("collect_empty");
|
||||
let src = dir.join("src");
|
||||
fs::create_dir_all(&src).unwrap();
|
||||
|
||||
let _guard = CWD_LOCK.lock().unwrap();
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let include: Vec<String> = Vec::new();
|
||||
let roots = default_roots();
|
||||
let result = collect_sources(&roots, &["c"], &[], &include);
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
|
||||
let sources = result.expect("empty src should return Ok");
|
||||
assert!(sources.is_empty(), "empty src should return empty vec");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn collect_sources_respects_excludes() {
|
||||
let dir = temp_dir("collect_exclude");
|
||||
let src = dir.join("src");
|
||||
let vendor = src.join("vendor");
|
||||
fs::create_dir_all(&vendor).unwrap();
|
||||
fs::write(src.join("main.c"), "").unwrap();
|
||||
fs::write(vendor.join("lib.c"), "").unwrap(); // should be excluded
|
||||
|
||||
let exclude = vec![vendor.clone()];
|
||||
let _guard = CWD_LOCK.lock().unwrap();
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let include: Vec<String> = Vec::new();
|
||||
let roots = default_roots();
|
||||
let result = collect_sources(&roots, &["c"], &exclude, &include);
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
|
||||
let sources = result.expect("should find sources");
|
||||
assert_eq!(sources.len(), 1);
|
||||
assert!(sources[0].ends_with("main.c"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn collect_sources_nested() {
|
||||
let dir = temp_dir("collect_nested");
|
||||
let src = dir.join("src");
|
||||
let sub = src.join("core").join("deep");
|
||||
fs::create_dir_all(&sub).unwrap();
|
||||
fs::write(src.join("main.c"), "").unwrap();
|
||||
fs::write(sub.join("nested.c"), "").unwrap();
|
||||
|
||||
let _guard = CWD_LOCK.lock().unwrap();
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let include: Vec<String> = Vec::new();
|
||||
let roots = default_roots();
|
||||
let result = collect_sources(&roots, &["c"], &[], &include);
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
|
||||
let sources = result.expect("should find sources");
|
||||
assert_eq!(sources.len(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn include_overrides_exclude() {
|
||||
let dir = temp_dir("include_override");
|
||||
let src = dir.join("src");
|
||||
let boot = src.join("boot");
|
||||
let arch = boot.join("arch");
|
||||
fs::create_dir_all(&arch).unwrap();
|
||||
fs::write(arch.join("start.s"), "").unwrap();
|
||||
fs::write(boot.join("skip.c"), "").unwrap();
|
||||
|
||||
let exclude = vec![boot.clone()];
|
||||
let include = vec!["src/boot/arch/**".to_string()];
|
||||
let _guard = CWD_LOCK.lock().unwrap();
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let roots = default_roots();
|
||||
let result = collect_sources(&roots, &["s", "c"], &exclude, &include);
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
|
||||
let sources = result.expect("should find sources");
|
||||
assert_eq!(sources.len(), 1);
|
||||
assert!(sources[0].ends_with("start.s"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exclude_glob_with_include_override() {
|
||||
let dir = temp_dir("exclude_glob");
|
||||
let src = dir.join("src");
|
||||
let legacy = src.join("legacy");
|
||||
let allow = legacy.join("allow");
|
||||
fs::create_dir_all(&allow).unwrap();
|
||||
fs::write(legacy.join("skip.c"), "").unwrap();
|
||||
fs::write(allow.join("keep.c"), "").unwrap();
|
||||
|
||||
let exclude = vec![dir.join("src"), dir.join(".")];
|
||||
let include = vec![
|
||||
"!src/legacy/**".to_string(),
|
||||
"src/legacy/allow/**".to_string(),
|
||||
];
|
||||
let _guard = CWD_LOCK.lock().unwrap();
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let roots = default_roots();
|
||||
let result = collect_sources(&roots, &["c"], &exclude, &include);
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
|
||||
let sources = result.expect("should find sources");
|
||||
assert_eq!(sources.len(), 1);
|
||||
assert!(sources[0].ends_with("keep.c"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exclude_glob_without_include_keeps_other_files() {
|
||||
let dir = temp_dir("exclude_glob_only");
|
||||
let src = dir.join("src");
|
||||
let gen_dir = src.join("gen");
|
||||
fs::create_dir_all(&gen_dir).unwrap();
|
||||
fs::write(src.join("main.c"), "").unwrap();
|
||||
fs::write(gen_dir.join("skip.c"), "").unwrap();
|
||||
|
||||
let exclude: Vec<PathBuf> = Vec::new();
|
||||
let include = vec!["!src/gen/**".to_string()];
|
||||
let _guard = CWD_LOCK.lock().unwrap();
|
||||
let prev = std::env::current_dir().unwrap();
|
||||
std::env::set_current_dir(&dir).unwrap();
|
||||
let roots = default_roots();
|
||||
let result = collect_sources(&roots, &["c"], &exclude, &include);
|
||||
std::env::set_current_dir(prev).unwrap();
|
||||
|
||||
let sources = result.expect("should find sources");
|
||||
assert_eq!(sources.len(), 1);
|
||||
assert!(sources[0].ends_with("main.c"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn normalize_relative_path() {
|
||||
let result = normalize_source_path(Path::new("./src/main.c"));
|
||||
assert_eq!(result, "./src/main.c");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_d_file_gcc_format() {
|
||||
let content = "target/obj/main.o: src/main.c src/utils.h \\\n src/core/types.h";
|
||||
let deps = parse_d_file(content);
|
||||
assert_eq!(deps, vec!["src/main.c", "src/utils.h", "src/core/types.h"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parse_d_file_msvc_format() {
|
||||
let content = "target/obj/main.obj: \\\n C:/sdk/include/windows.h \\\n src/main.c";
|
||||
let deps = parse_d_file(content);
|
||||
assert_eq!(deps, vec!["C:/sdk/include/windows.h", "src/main.c"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn needs_rebuild_header_modified() {
|
||||
let dir = temp_dir("rebuild_header");
|
||||
let src = dir.join("test.c");
|
||||
let header = dir.join("test.h");
|
||||
let obj = dir.join("test.o");
|
||||
let d_file = dir.join("test.d");
|
||||
|
||||
fs::write(&src, "int main() {}").unwrap();
|
||||
fs::write(&header, "#define A 1").unwrap();
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
fs::write(&obj, "").unwrap();
|
||||
|
||||
let d_content = format!(
|
||||
"{}: {} {}",
|
||||
obj.to_string_lossy(),
|
||||
src.to_string_lossy(),
|
||||
header.to_string_lossy()
|
||||
);
|
||||
fs::write(&d_file, d_content).unwrap();
|
||||
|
||||
assert!(
|
||||
!needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
|
||||
"should be fresh"
|
||||
);
|
||||
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
fs::write(&header, "#define A 2").unwrap(); // modify header
|
||||
|
||||
assert!(
|
||||
needs_rebuild(&src.to_string_lossy(), &obj.to_string_lossy()),
|
||||
"changed header should trigger rebuild"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn asm_lang_flag_returns_correct_flag() {
|
||||
assert_eq!(asm_lang_flag("foo.S"), Some("assembler-with-cpp"));
|
||||
assert_eq!(asm_lang_flag("bar.s"), Some("assembler"));
|
||||
assert_eq!(asm_lang_flag("baz.asm"), Some("assembler"));
|
||||
assert_eq!(asm_lang_flag("main.c"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn source_extensions_parses_language_string() {
|
||||
let c = source_extensions("c");
|
||||
assert!(c.contains(&"c"));
|
||||
assert!(!c.contains(&"cpp"));
|
||||
|
||||
let cpp = source_extensions("c++");
|
||||
assert!(cpp.contains(&"cpp"));
|
||||
assert!(cpp.contains(&"cxx"));
|
||||
assert!(cpp.contains(&"cc"));
|
||||
|
||||
let asm = source_extensions("asm");
|
||||
assert!(asm.contains(&"s"));
|
||||
assert!(asm.contains(&"S"));
|
||||
assert!(asm.contains(&"asm"));
|
||||
|
||||
let mixed = source_extensions("c, c++");
|
||||
assert!(mixed.contains(&"c"));
|
||||
assert!(mixed.contains(&"cpp"));
|
||||
|
||||
let unknown = source_extensions("rust");
|
||||
assert_eq!(unknown, vec!["c"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn elapsed_secs_returns_positive() {
|
||||
let start = std::time::Instant::now();
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
let elapsed = elapsed_secs(start);
|
||||
assert!(elapsed > 0.0);
|
||||
}
|
||||
}
|
||||
1084
src/core/build/engine.rs
Normal file
1084
src/core/build/engine.rs
Normal file
File diff suppressed because it is too large
Load Diff
83
src/core/build/language/asm/common.rs
Normal file
83
src/core/build/language/asm/common.rs
Normal file
@@ -0,0 +1,83 @@
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::builder::artifact;
|
||||
use crate::core::build::common;
|
||||
use std::path::Path;
|
||||
use std::time::Instant;
|
||||
|
||||
pub fn filter_asm_flags(flags: &[String]) -> Vec<String> {
|
||||
flags
|
||||
.iter()
|
||||
.filter(|f| {
|
||||
let f = f.as_str();
|
||||
f.starts_with("-I") || f.starts_with("-i") || f == "-g"
|
||||
})
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn build_assembly<F>(
|
||||
ctx: &BuildContext,
|
||||
backend_name: &str,
|
||||
default_assembler: &str,
|
||||
extensions: &[&str],
|
||||
build_object: F,
|
||||
) -> Result<f64, String>
|
||||
where
|
||||
F: Fn(&str, &str, &str, &BuildContext) -> Result<(), String> + Sync,
|
||||
{
|
||||
let lang = ctx.language.to_lowercase();
|
||||
if lang.split(',').any(|p| p.trim() != "asm") {
|
||||
return Err(format!(
|
||||
"{backend_name} backend requires build.language = \"asm\""
|
||||
));
|
||||
}
|
||||
|
||||
let assembler = if ctx.compiler.is_empty() {
|
||||
default_assembler
|
||||
} else {
|
||||
ctx.compiler
|
||||
};
|
||||
|
||||
let start_time = Instant::now();
|
||||
let sources = common::collect_sources(
|
||||
ctx.source_roots,
|
||||
extensions,
|
||||
ctx.exclude_dirs,
|
||||
ctx.include_paths,
|
||||
)?;
|
||||
let obj_dir = match ctx.target_dir {
|
||||
Some(dir) => Path::new(dir).join("obj"),
|
||||
None => Path::new("./target").join(ctx.profile).join("obj"),
|
||||
};
|
||||
let objects = build_objects_common(assembler, &sources, &obj_dir, ctx, &build_object)?;
|
||||
|
||||
if ctx.kind == "staticlib" {
|
||||
return artifact::archive_static(ctx, &objects, start_time);
|
||||
}
|
||||
|
||||
artifact::link_binary(ctx, &objects, "cc", start_time)
|
||||
}
|
||||
|
||||
fn build_objects_common<F>(
|
||||
assembler: &str,
|
||||
sources: &[String],
|
||||
obj_dir: &Path,
|
||||
ctx: &BuildContext,
|
||||
build_object: &F,
|
||||
) -> Result<Vec<String>, String>
|
||||
where
|
||||
F: Fn(&str, &str, &str, &BuildContext) -> Result<(), String> + Sync,
|
||||
{
|
||||
let objects: Vec<String> = sources
|
||||
.iter()
|
||||
.map(|s| common::object_path(obj_dir, s, "o"))
|
||||
.collect();
|
||||
|
||||
common::parallel_build(
|
||||
sources.len(),
|
||||
|i| build_object(assembler, &sources[i], &objects[i], ctx),
|
||||
ctx.codegen_units,
|
||||
)?;
|
||||
|
||||
Ok(objects)
|
||||
}
|
||||
47
src/core/build/language/asm/fasm/mod.rs
Normal file
47
src/core/build/language/asm/fasm/mod.rs
Normal file
@@ -0,0 +1,47 @@
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::common;
|
||||
use crate::core::build::language::asm::common as asm;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
pub fn build(ctx: &BuildContext) -> Result<f64, String> {
|
||||
asm::build_assembly(ctx, "FASM", "fasm", &["asm", "fasm"], build_object)
|
||||
}
|
||||
|
||||
pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
common::collect_sources(
|
||||
ctx.source_roots,
|
||||
&["asm", "fasm"],
|
||||
ctx.exclude_dirs,
|
||||
ctx.include_paths,
|
||||
)
|
||||
}
|
||||
|
||||
fn build_object(
|
||||
assembler: &str,
|
||||
source: &str,
|
||||
obj_path: &str,
|
||||
ctx: &BuildContext,
|
||||
) -> Result<(), String> {
|
||||
if let Some(parent) = Path::new(obj_path).parent() {
|
||||
fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
|
||||
}
|
||||
|
||||
if !common::needs_rebuild(source, obj_path) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let mut cmd = Command::new(assembler);
|
||||
cmd.arg(source).arg(obj_path);
|
||||
|
||||
for flag in crate::core::build::language::asm::common::filter_asm_flags(ctx.cflags) {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
|
||||
if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
|
||||
eprintln!("[dcr] {:?}", cmd);
|
||||
}
|
||||
|
||||
common::run_command_sync_output(&mut cmd)
|
||||
}
|
||||
73
src/core/build/language/asm/gas/mod.rs
Normal file
73
src/core/build/language/asm/gas/mod.rs
Normal file
@@ -0,0 +1,73 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::common;
|
||||
use crate::core::build::language::asm::common as asm;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
pub fn build(ctx: &BuildContext) -> Result<f64, String> {
|
||||
// Use full path to as
|
||||
let as_path = std::process::Command::new("which")
|
||||
.arg("as")
|
||||
.output()
|
||||
.ok()
|
||||
.and_then(|o| String::from_utf8(o.stdout).ok())
|
||||
.map(|s| s.trim().to_string())
|
||||
.filter(|s| !s.is_empty())
|
||||
.unwrap_or_else(|| "as".to_string());
|
||||
asm::build_assembly(ctx, "GAS", &as_path, &["s"], build_object)
|
||||
}
|
||||
|
||||
pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
common::collect_sources(
|
||||
ctx.source_roots,
|
||||
&["s"],
|
||||
ctx.exclude_dirs,
|
||||
ctx.include_paths,
|
||||
)
|
||||
}
|
||||
|
||||
fn build_object(
|
||||
assembler: &str,
|
||||
source: &str,
|
||||
obj_path: &str,
|
||||
ctx: &BuildContext,
|
||||
) -> Result<(), String> {
|
||||
if let Some(parent) = Path::new(obj_path).parent() {
|
||||
fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
|
||||
}
|
||||
|
||||
if !common::needs_rebuild(source, obj_path) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let mut cmd = Command::new(assembler);
|
||||
cmd.arg(source).arg("-o").arg(obj_path);
|
||||
|
||||
for flag in crate::core::build::language::asm::common::filter_asm_flags(ctx.cflags) {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
|
||||
if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
|
||||
eprintln!("[dcr] {:?}", cmd);
|
||||
}
|
||||
|
||||
common::run_command_sync_output(&mut cmd)
|
||||
}
|
||||
51
src/core/build/language/asm/masm/mod.rs
Normal file
51
src/core/build/language/asm/masm/mod.rs
Normal file
@@ -0,0 +1,51 @@
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::common;
|
||||
use crate::core::build::language::asm::common as asm;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
pub fn build(ctx: &BuildContext) -> Result<f64, String> {
|
||||
asm::build_assembly(ctx, "MASM", "ml", &["asm"], build_object)
|
||||
}
|
||||
|
||||
pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
common::collect_sources(
|
||||
ctx.source_roots,
|
||||
&["asm"],
|
||||
ctx.exclude_dirs,
|
||||
ctx.include_paths,
|
||||
)
|
||||
}
|
||||
|
||||
fn build_object(
|
||||
assembler: &str,
|
||||
source: &str,
|
||||
obj_path: &str,
|
||||
ctx: &BuildContext,
|
||||
) -> Result<(), String> {
|
||||
if let Some(parent) = Path::new(obj_path).parent() {
|
||||
fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
|
||||
}
|
||||
|
||||
if !common::needs_rebuild(source, obj_path) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let mut cmd = Command::new(assembler);
|
||||
cmd.arg("/nologo")
|
||||
.arg("/c")
|
||||
.arg("/Fo")
|
||||
.arg(obj_path)
|
||||
.arg(source);
|
||||
|
||||
for flag in crate::core::build::language::asm::common::filter_asm_flags(ctx.cflags) {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
|
||||
if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
|
||||
eprintln!("[dcr] {:?}", cmd);
|
||||
}
|
||||
|
||||
common::run_command_sync_output(&mut cmd)
|
||||
}
|
||||
38
src/core/build/language/asm/mod.rs
Normal file
38
src/core/build/language/asm/mod.rs
Normal file
@@ -0,0 +1,38 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
pub mod common;
|
||||
pub mod fasm;
|
||||
pub mod gas;
|
||||
pub mod masm;
|
||||
pub mod nasm;
|
||||
|
||||
use crate::core::build::language::Language;
|
||||
|
||||
pub struct Asm;
|
||||
|
||||
impl Language for Asm {
|
||||
fn id(&self) -> &'static str {
|
||||
"asm"
|
||||
}
|
||||
fn extensions(&self) -> &'static [&'static str] {
|
||||
&["s", "S", "asm"]
|
||||
}
|
||||
fn matches_token(&self, token: &str) -> bool {
|
||||
token.eq_ignore_ascii_case("asm")
|
||||
}
|
||||
}
|
||||
107
src/core/build/language/asm/nasm/mod.rs
Normal file
107
src/core/build/language/asm/nasm/mod.rs
Normal file
@@ -0,0 +1,107 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::common;
|
||||
use crate::core::build::language::asm::common as asm;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
pub fn build(ctx: &BuildContext) -> Result<f64, String> {
|
||||
asm::build_assembly(ctx, "NASM", "nasm", &["asm"], build_object)
|
||||
}
|
||||
|
||||
pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
// NASM handles .asm only (not .s which is GAS syntax, not .S which is GCC preprocessed)
|
||||
common::collect_sources(
|
||||
ctx.source_roots,
|
||||
&["asm"],
|
||||
ctx.exclude_dirs,
|
||||
ctx.include_paths,
|
||||
)
|
||||
}
|
||||
|
||||
fn build_object(
|
||||
assembler: &str,
|
||||
source: &str,
|
||||
obj_path: &str,
|
||||
ctx: &BuildContext,
|
||||
) -> Result<(), String> {
|
||||
if let Some(parent) = Path::new(obj_path).parent() {
|
||||
fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
|
||||
}
|
||||
|
||||
if !common::needs_rebuild(source, obj_path) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let format = nasm_format(ctx.platform);
|
||||
|
||||
let mut cmd = Command::new(assembler);
|
||||
cmd.arg("-f")
|
||||
.arg(format)
|
||||
.arg(source)
|
||||
.arg("-o")
|
||||
.arg(obj_path);
|
||||
|
||||
for flag in crate::core::build::language::asm::common::filter_asm_flags(ctx.cflags) {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
|
||||
if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
|
||||
eprintln!("[dcr] {:?}", cmd);
|
||||
}
|
||||
|
||||
common::run_command_sync_output(&mut cmd)
|
||||
}
|
||||
|
||||
fn nasm_format(platform: Option<&str>) -> &'static str {
|
||||
if let Some(p) = platform {
|
||||
let p = p.to_lowercase().replace('-', "_");
|
||||
if p == "x86" || (p.starts_with('i') && p.ends_with("86") && p.len() == 4) {
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
return "macho32";
|
||||
}
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
return "win32";
|
||||
}
|
||||
#[cfg(not(any(target_os = "macos", target_os = "windows")))]
|
||||
{
|
||||
return "elf32";
|
||||
}
|
||||
}
|
||||
}
|
||||
#[cfg(target_os = "linux")]
|
||||
{
|
||||
"elf64"
|
||||
}
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
"macho64"
|
||||
}
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
"win64"
|
||||
}
|
||||
#[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "windows")))]
|
||||
{
|
||||
"elf64"
|
||||
}
|
||||
}
|
||||
32
src/core/build/language/c/mod.rs
Normal file
32
src/core/build/language/c/mod.rs
Normal file
@@ -0,0 +1,32 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use crate::core::build::language::Language;
|
||||
|
||||
pub struct C;
|
||||
|
||||
impl Language for C {
|
||||
fn id(&self) -> &'static str {
|
||||
"c"
|
||||
}
|
||||
fn extensions(&self) -> &'static [&'static str] {
|
||||
&["c"]
|
||||
}
|
||||
fn matches_token(&self, token: &str) -> bool {
|
||||
token.eq_ignore_ascii_case("c")
|
||||
}
|
||||
}
|
||||
34
src/core/build/language/cxx/mod.rs
Normal file
34
src/core/build/language/cxx/mod.rs
Normal file
@@ -0,0 +1,34 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
pub mod qt;
|
||||
|
||||
use crate::core::build::language::Language;
|
||||
|
||||
pub struct Cxx;
|
||||
|
||||
impl Language for Cxx {
|
||||
fn id(&self) -> &'static str {
|
||||
"cxx"
|
||||
}
|
||||
fn extensions(&self) -> &'static [&'static str] {
|
||||
&["cpp", "cxx", "cc"]
|
||||
}
|
||||
fn matches_token(&self, token: &str) -> bool {
|
||||
matches!(token.to_lowercase().as_str(), "c++" | "cpp" | "cxx")
|
||||
}
|
||||
}
|
||||
137
src/core/build/language/cxx/qt.rs
Normal file
137
src/core/build/language/cxx/qt.rs
Normal file
@@ -0,0 +1,137 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::common;
|
||||
use crate::utils::build::run_pkg_config;
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
|
||||
pub fn process_qt(ctx: &BuildContext, build_dir: &Path) -> Result<Option<PathBuf>, String> {
|
||||
let qt_dir = build_dir.join("qt");
|
||||
fs::create_dir_all(&qt_dir).map_err(|e| format!("Failed to create qt dir: {e}"))?;
|
||||
|
||||
let extensions = vec!["ui", "qrc", "h", "hpp", "hxx"];
|
||||
let files = common::collect_sources(
|
||||
ctx.source_roots,
|
||||
&extensions,
|
||||
ctx.exclude_dirs,
|
||||
ctx.include_paths,
|
||||
)?;
|
||||
|
||||
let mut qt_moc_args = Vec::new();
|
||||
let qt_modules = vec!["Qt6Core", "Qt6Widgets", "Qt6Gui", "Qt6Svg"];
|
||||
|
||||
for module in qt_modules {
|
||||
if let Ok(cflags) = run_pkg_config(module, "--cflags") {
|
||||
for flag in cflags.split_whitespace() {
|
||||
if flag.starts_with("-I") || flag.starts_with("-D") {
|
||||
qt_moc_args.push(flag.to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut generated_any = false;
|
||||
|
||||
for file in files {
|
||||
let path = Path::new(&file);
|
||||
let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("");
|
||||
|
||||
match ext {
|
||||
"ui" => {
|
||||
if let Some(uic) = ctx.uic {
|
||||
let out_name = path.file_stem().unwrap().to_str().unwrap();
|
||||
let out_file = qt_dir.join(format!("ui_{out_name}.h"));
|
||||
run_command(
|
||||
uic,
|
||||
&[path.to_str().unwrap(), "-o", out_file.to_str().unwrap()],
|
||||
ctx.verbose,
|
||||
)?;
|
||||
generated_any = true;
|
||||
}
|
||||
}
|
||||
"qrc" => {
|
||||
if let Some(rcc) = ctx.rcc {
|
||||
let out_name = path.file_stem().unwrap().to_str().unwrap();
|
||||
let out_file = qt_dir.join(format!("qrc_{out_name}.cpp"));
|
||||
run_command(
|
||||
rcc,
|
||||
&[
|
||||
path.to_str().unwrap(),
|
||||
"-name",
|
||||
out_name,
|
||||
"-o",
|
||||
out_file.to_str().unwrap(),
|
||||
],
|
||||
ctx.verbose,
|
||||
)?;
|
||||
generated_any = true;
|
||||
}
|
||||
}
|
||||
"h" | "hpp" | "hxx" => {
|
||||
if let Some(moc) = ctx.moc {
|
||||
let content = fs::read_to_string(path)
|
||||
.map_err(|e| format!("Failed to read {}: {e}", path.display()))?;
|
||||
if content.contains("Q_OBJECT") {
|
||||
let out_name = path.file_stem().unwrap().to_str().unwrap();
|
||||
let out_file = qt_dir.join(format!("moc_{out_name}.cpp"));
|
||||
|
||||
let mut moc_args = Vec::new();
|
||||
|
||||
for arg in &qt_moc_args {
|
||||
moc_args.push(arg.as_str());
|
||||
}
|
||||
|
||||
for inc in ctx.include_paths.iter().chain(ctx.include_dirs.iter()) {
|
||||
moc_args.push("-I");
|
||||
moc_args.push(inc);
|
||||
}
|
||||
|
||||
moc_args.push(path.to_str().unwrap());
|
||||
moc_args.push("-o");
|
||||
moc_args.push(out_file.to_str().unwrap());
|
||||
|
||||
run_command(moc, &moc_args, ctx.verbose)?;
|
||||
generated_any = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
if generated_any {
|
||||
Ok(Some(qt_dir))
|
||||
} else {
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
fn run_command(cmd_path: &str, args: &[&str], verbose: bool) -> Result<(), String> {
|
||||
let mut cmd = Command::new(cmd_path);
|
||||
cmd.args(args);
|
||||
if verbose || std::env::var("DCR_DEBUG").is_ok() {
|
||||
eprintln!("[dcr] {:?}", cmd);
|
||||
}
|
||||
match cmd.status() {
|
||||
Ok(s) if s.success() => Ok(()),
|
||||
Ok(s) => Err(format!("Command {} failed with status {}", cmd_path, s)),
|
||||
Err(e) => Err(format!("Failed to execute {}: {}", cmd_path, e)),
|
||||
}
|
||||
}
|
||||
58
src/core/build/language/llvm_ir/mod.rs
Normal file
58
src/core/build/language/llvm_ir/mod.rs
Normal file
@@ -0,0 +1,58 @@
|
||||
use crate::core::build::builder::BuildContext;
|
||||
use crate::core::build::common;
|
||||
use crate::core::build::language::Language;
|
||||
use crate::core::build::language::asm::common as asm;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
use std::process::Command;
|
||||
|
||||
pub struct LlvmIr;
|
||||
|
||||
impl Language for LlvmIr {
|
||||
fn id(&self) -> &'static str {
|
||||
"llvm_ir"
|
||||
}
|
||||
fn extensions(&self) -> &'static [&'static str] {
|
||||
&["ll"]
|
||||
}
|
||||
fn matches_token(&self, token: &str) -> bool {
|
||||
matches!(token.to_lowercase().as_str(), "llvm_ir" | "llvm-ir" | "ll")
|
||||
}
|
||||
}
|
||||
|
||||
pub fn build(ctx: &BuildContext) -> Result<f64, String> {
|
||||
asm::build_assembly(ctx, "LLVM-IR", "llc", &["ll"], build_object)
|
||||
}
|
||||
|
||||
pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
|
||||
common::collect_sources(
|
||||
ctx.source_roots,
|
||||
&["ll"],
|
||||
ctx.exclude_dirs,
|
||||
ctx.include_paths,
|
||||
)
|
||||
}
|
||||
|
||||
fn build_object(
|
||||
assembler: &str,
|
||||
source: &str,
|
||||
obj_path: &str,
|
||||
ctx: &BuildContext,
|
||||
) -> Result<(), String> {
|
||||
if let Some(parent) = Path::new(obj_path).parent() {
|
||||
fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
|
||||
}
|
||||
|
||||
if !common::needs_rebuild(source, obj_path) {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let mut cmd = Command::new(assembler);
|
||||
cmd.arg("-filetype=obj").arg(source).arg("-o").arg(obj_path);
|
||||
|
||||
for flag in ctx.cflags {
|
||||
cmd.arg(flag);
|
||||
}
|
||||
|
||||
common::run_command_sync_output(&mut cmd)
|
||||
}
|
||||
57
src/core/build/language/mod.rs
Normal file
57
src/core/build/language/mod.rs
Normal file
@@ -0,0 +1,57 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
pub mod asm;
|
||||
pub mod c;
|
||||
pub mod cxx;
|
||||
pub mod llvm_ir;
|
||||
|
||||
pub trait Language {
|
||||
fn id(&self) -> &'static str;
|
||||
fn extensions(&self) -> &'static [&'static str];
|
||||
fn matches_token(&self, token: &str) -> bool;
|
||||
}
|
||||
|
||||
pub fn languages() -> [&'static dyn Language; 4] {
|
||||
[&c::C, &cxx::Cxx, &asm::Asm, &llvm_ir::LlvmIr]
|
||||
}
|
||||
|
||||
pub fn language_for_token(token: &str) -> Option<&'static dyn Language> {
|
||||
languages().into_iter().find(|l| l.matches_token(token))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn tokens_resolve_to_languages() {
|
||||
assert_eq!(language_for_token("c").unwrap().id(), "c");
|
||||
assert_eq!(language_for_token("c++").unwrap().id(), "cxx");
|
||||
assert_eq!(language_for_token("cpp").unwrap().id(), "cxx");
|
||||
assert_eq!(language_for_token("cxx").unwrap().id(), "cxx");
|
||||
assert_eq!(language_for_token("asm").unwrap().id(), "asm");
|
||||
assert!(language_for_token("rust").is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn languages_expose_expected_extensions() {
|
||||
assert_eq!(c::C.extensions(), &["c"]);
|
||||
assert_eq!(cxx::Cxx.extensions(), &["cpp", "cxx", "cc"]);
|
||||
assert_eq!(asm::Asm.extensions(), &["s", "S", "asm"]);
|
||||
}
|
||||
}
|
||||
29
src/core/build/mod.rs
Normal file
29
src/core/build/mod.rs
Normal file
@@ -0,0 +1,29 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
pub mod builder;
|
||||
pub mod cache;
|
||||
pub mod common;
|
||||
pub mod engine;
|
||||
pub mod language;
|
||||
pub mod report;
|
||||
pub mod resolve;
|
||||
pub mod steps;
|
||||
|
||||
pub use engine::run_build;
|
||||
pub use report::{BuildEvent, BuildReporter, BuildRequest};
|
||||
pub use resolve::get_build_string_with_profile;
|
||||
83
src/core/build/report.rs
Normal file
83
src/core/build/report.rs
Normal file
@@ -0,0 +1,83 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
// The reporter decouples the build engine from any particular frontend: the CLI
|
||||
// renders events as coloured lines, a TUI/GUI would push them into a widget and
|
||||
// MCP would serialise them to JSON. The engine only ever calls `on_event`.
|
||||
|
||||
use std::sync::{Arc, atomic::AtomicBool};
|
||||
|
||||
pub struct BuildRequest {
|
||||
pub profile: String,
|
||||
pub target: Option<String>,
|
||||
pub force: bool,
|
||||
pub verbose: bool,
|
||||
pub workspace: Option<String>,
|
||||
pub cancel: Arc<AtomicBool>,
|
||||
}
|
||||
|
||||
#[allow(dead_code)]
|
||||
pub struct BuildOutcome {
|
||||
pub secs: f64,
|
||||
}
|
||||
|
||||
pub struct BuildError {
|
||||
pub message: String,
|
||||
}
|
||||
|
||||
impl From<String> for BuildError {
|
||||
fn from(message: String) -> Self {
|
||||
BuildError { message }
|
||||
}
|
||||
}
|
||||
|
||||
pub enum BuildEvent<'a> {
|
||||
TargetStart {
|
||||
index: usize,
|
||||
total: usize,
|
||||
target: &'a str,
|
||||
},
|
||||
ProjectStart {
|
||||
name: &'a str,
|
||||
profile: &'a str,
|
||||
target: &'a str,
|
||||
},
|
||||
DepBuilding {
|
||||
name: &'a str,
|
||||
version: &'a str,
|
||||
},
|
||||
DepReady {
|
||||
name: &'a str,
|
||||
version: &'a str,
|
||||
rebuilt: bool,
|
||||
},
|
||||
Compiling {
|
||||
name: &'a str,
|
||||
version: &'a str,
|
||||
},
|
||||
CompilerOutput {
|
||||
stream: &'a str,
|
||||
text: &'a str,
|
||||
},
|
||||
Finished {
|
||||
secs: f64,
|
||||
},
|
||||
}
|
||||
|
||||
pub trait BuildReporter {
|
||||
fn on_event(&mut self, event: BuildEvent<'_>);
|
||||
}
|
||||
232
src/core/build/resolve.rs
Normal file
232
src/core/build/resolve.rs
Normal file
@@ -0,0 +1,232 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use crate::core::build_config::Config;
|
||||
use crate::utils::build::{get_config_str, normalize_target_os, profile_table};
|
||||
|
||||
pub(crate) fn get_config_value_raw(
|
||||
config: &Config,
|
||||
section: &str,
|
||||
field: &str,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
) -> Option<toml::Value> {
|
||||
// Order: target.profile, profile.target, target, profile, base
|
||||
let keys = [
|
||||
target.map(|t| {
|
||||
format!(
|
||||
"{}.{}.{}.{}",
|
||||
section,
|
||||
normalize_target_os(t),
|
||||
profile,
|
||||
field
|
||||
)
|
||||
}),
|
||||
target.map(|t| {
|
||||
format!(
|
||||
"{}.{}.{}.{}",
|
||||
section,
|
||||
profile,
|
||||
normalize_target_os(t),
|
||||
field
|
||||
)
|
||||
}),
|
||||
target.map(|t| format!("{}.{}.{}", section, normalize_target_os(t), field)),
|
||||
Some(format!("{}.{}.{}", section, profile, field)),
|
||||
Some(format!("{}.{}", section, field)),
|
||||
];
|
||||
for key in keys.into_iter().flatten() {
|
||||
if let Some(val) = config.get(&key) {
|
||||
return Some(val.clone());
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub(crate) fn get_inherit(
|
||||
config: &Config,
|
||||
section: &str,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
) -> bool {
|
||||
get_config_value_raw(config, section, "inherit", profile, target)
|
||||
.and_then(|v| v.as_bool())
|
||||
.unwrap_or(true)
|
||||
}
|
||||
|
||||
pub(crate) fn get_config_value(
|
||||
config: &Config,
|
||||
section: &str,
|
||||
field: &str,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
) -> Option<String> {
|
||||
get_config_value_raw(config, section, field, profile, target)
|
||||
.and_then(|v| v.as_str().map(|s| s.trim().to_string()))
|
||||
.filter(|s| !s.is_empty())
|
||||
}
|
||||
|
||||
pub(crate) fn get_string_with_profile_and_target(
|
||||
config: &Config,
|
||||
field: &str,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
) -> String {
|
||||
if get_inherit(config, "build", profile, target) {
|
||||
get_config_value(config, "build", field, profile, target)
|
||||
.unwrap_or_else(|| get_config_str(config, &format!("build.{field}")))
|
||||
} else {
|
||||
get_config_value(config, "build", field, profile, target).unwrap_or_default()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_build_string_with_profile(config: &Config, field: &str, profile: &str) -> String {
|
||||
get_string_with_profile_and_target(config, field, profile, None)
|
||||
}
|
||||
|
||||
pub(crate) fn get_lang_string(
|
||||
config: &Config,
|
||||
lang: &str,
|
||||
field: &str,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
) -> Option<String> {
|
||||
get_config_value(config, &format!("build.{lang}"), field, profile, target)
|
||||
}
|
||||
|
||||
pub(crate) fn get_lang_list(
|
||||
config: &Config,
|
||||
lang: &str,
|
||||
field: &str,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
) -> Result<Vec<String>, String> {
|
||||
match get_config_value_raw(config, &format!("build.{lang}"), field, profile, target) {
|
||||
Some(val) => parse_string_array(&val, field),
|
||||
None => Ok(Vec::new()),
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn parse_string_array(value: &toml::Value, key: &str) -> Result<Vec<String>, String> {
|
||||
let arr = value
|
||||
.as_array()
|
||||
.ok_or_else(|| format!("{key} must be an array of strings"))?;
|
||||
let mut out = Vec::new();
|
||||
for item in arr {
|
||||
let s = item
|
||||
.as_str()
|
||||
.ok_or_else(|| format!("{key} must be an array of strings"))?;
|
||||
out.push(s.to_string());
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
pub(crate) fn get_list_with_profile_and_target(
|
||||
config: &Config,
|
||||
field: &str,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
) -> Result<Vec<String>, String> {
|
||||
let inherit = get_inherit(config, "build", profile, target);
|
||||
let mut out = if inherit {
|
||||
get_config_list(config, &format!("build.{field}"))?
|
||||
} else {
|
||||
Vec::new()
|
||||
};
|
||||
if let Some(val) = get_config_value_raw(config, "build", field, profile, target) {
|
||||
if let Some(_arr) = val.as_array() {
|
||||
let is_base = inherit
|
||||
&& config
|
||||
.get(&format!("build.{field}"))
|
||||
.map(|v| v == &val)
|
||||
.unwrap_or(false);
|
||||
if !is_base {
|
||||
let custom = parse_string_array(&val, &format!("build.{field}"))?;
|
||||
if inherit {
|
||||
out.extend(custom);
|
||||
} else {
|
||||
out = custom;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if inherit {
|
||||
if let Some(table) = profile_table(config, profile)
|
||||
&& let Some(value) = table.get(field)
|
||||
{
|
||||
let mut extra = parse_string_array(value, &format!("build.{profile}.{field}"))?;
|
||||
out.append(&mut extra);
|
||||
}
|
||||
if let Some(t) = target {
|
||||
let normalized_t = normalize_target_os(t);
|
||||
if let Some(table) = profile_table(config, normalized_t)
|
||||
&& let Some(value) = table.get(field)
|
||||
{
|
||||
let mut extra =
|
||||
parse_string_array(value, &format!("build.{normalized_t}.{field}"))?;
|
||||
out.append(&mut extra);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
pub(crate) fn get_list_with_profile(
|
||||
config: &Config,
|
||||
field: &str,
|
||||
profile: &str,
|
||||
) -> Result<Vec<String>, String> {
|
||||
get_list_with_profile_and_target(config, field, profile, None)
|
||||
}
|
||||
|
||||
pub(crate) fn get_targets(config: &Config, profile: &str) -> Result<Vec<String>, String> {
|
||||
get_list_with_profile(config, "targets", profile)
|
||||
}
|
||||
|
||||
pub(crate) fn get_config_list(config: &Config, key: &str) -> Result<Vec<String>, String> {
|
||||
let value = match config.get(key) {
|
||||
Some(v) => v,
|
||||
None => return Ok(Vec::new()),
|
||||
};
|
||||
let arr = value
|
||||
.as_array()
|
||||
.ok_or_else(|| format!("{key} must be an array of strings"))?;
|
||||
let mut out = Vec::new();
|
||||
for item in arr {
|
||||
let s = item
|
||||
.as_str()
|
||||
.ok_or_else(|| format!("{key} must be an array of strings"))?;
|
||||
out.push(s.to_string());
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::utils::build::normalize_target_os;
|
||||
|
||||
#[test]
|
||||
fn test_normalize_target_os() {
|
||||
assert_eq!(normalize_target_os("linux"), "x86_64-unknown-linux-gnu");
|
||||
assert_eq!(normalize_target_os("macos"), "x86_64-apple-darwin");
|
||||
assert_eq!(normalize_target_os("windows"), "x86_64-pc-windows-msvc");
|
||||
assert_eq!(
|
||||
normalize_target_os("x86_64-unknown-linux-gnu"),
|
||||
"x86_64-unknown-linux-gnu"
|
||||
);
|
||||
assert_eq!(normalize_target_os("unknown"), "unknown");
|
||||
}
|
||||
}
|
||||
398
src/core/build/steps.rs
Normal file
398
src/core/build/steps.rs
Normal file
@@ -0,0 +1,398 @@
|
||||
// DCR — Cargo-like C/C++ project manager.
|
||||
//
|
||||
// Copyright (C) 2026 Dexoron (Bezotechestvo Vladimir) <main@dexoron.su>
|
||||
//
|
||||
// This program is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// This program is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
|
||||
use crate::core::build::engine::ToolchainExecs;
|
||||
use crate::core::build_config::Config;
|
||||
use crate::utils::build::{VersionInfo, profile_table, substitute_vars};
|
||||
use glob::glob;
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(crate) struct BuildStep {
|
||||
name: String,
|
||||
input: String,
|
||||
output: String,
|
||||
cmd: String,
|
||||
}
|
||||
|
||||
pub(crate) struct StepVars<'a> {
|
||||
pub(crate) profile: &'a str,
|
||||
pub(crate) version: &'a str,
|
||||
pub(crate) version_major: &'a str,
|
||||
pub(crate) version_minor: &'a str,
|
||||
pub(crate) version_patch: &'a str,
|
||||
pub(crate) version_suffix: &'a str,
|
||||
pub(crate) version_suffix_dash: &'a str,
|
||||
}
|
||||
|
||||
fn get_build_steps_from_value(value: &toml::Value, key: &str) -> Result<Vec<BuildStep>, String> {
|
||||
let arr = value
|
||||
.as_array()
|
||||
.ok_or_else(|| format!("{key} must be an array"))?;
|
||||
let mut out = Vec::new();
|
||||
for item in arr {
|
||||
let tbl = item
|
||||
.as_table()
|
||||
.ok_or_else(|| format!("{key} entries must be tables"))?;
|
||||
let name = tbl
|
||||
.get("name")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("")
|
||||
.trim()
|
||||
.to_string();
|
||||
let input = tbl
|
||||
.get("in")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("")
|
||||
.trim()
|
||||
.to_string();
|
||||
let output = tbl
|
||||
.get("out")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("")
|
||||
.trim()
|
||||
.to_string();
|
||||
let cmd = tbl
|
||||
.get("cmd")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("")
|
||||
.trim()
|
||||
.to_string();
|
||||
if name.is_empty() || input.is_empty() || output.is_empty() || cmd.is_empty() {
|
||||
return Err(format!("{key} entries must include name, in, out, cmd"));
|
||||
}
|
||||
out.push(BuildStep {
|
||||
name,
|
||||
input,
|
||||
output,
|
||||
cmd,
|
||||
});
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
pub(crate) fn get_build_steps_with_profile(
|
||||
config: &Config,
|
||||
field: &str,
|
||||
profile: &str,
|
||||
) -> Result<Vec<BuildStep>, String> {
|
||||
if let Some(table) = profile_table(config, profile)
|
||||
&& let Some(value) = table.get(field)
|
||||
{
|
||||
return get_build_steps_from_value(value, &format!("build.{profile}.{field}"));
|
||||
}
|
||||
get_build_steps(config, &format!("build.{field}"))
|
||||
}
|
||||
|
||||
fn get_build_steps(config: &Config, key: &str) -> Result<Vec<BuildStep>, String> {
|
||||
let value = match config.get(key) {
|
||||
Some(v) => v,
|
||||
None => return Ok(Vec::new()),
|
||||
};
|
||||
get_build_steps_from_value(value, key)
|
||||
}
|
||||
|
||||
use crate::core::build::report::{BuildEvent, BuildReporter};
|
||||
use std::sync::{Arc, atomic::AtomicBool};
|
||||
|
||||
pub(crate) fn run_build_steps(
|
||||
steps: &[BuildStep],
|
||||
tools: &ToolchainExecs,
|
||||
step_flags: &str,
|
||||
vars: &StepVars,
|
||||
cancel: &Arc<AtomicBool>,
|
||||
rep: &mut dyn BuildReporter,
|
||||
) -> Result<(), String> {
|
||||
for step in steps {
|
||||
if cancel.load(std::sync::atomic::Ordering::SeqCst) {
|
||||
return Err("Build interrupted".to_string());
|
||||
}
|
||||
run_build_step(step, tools, step_flags, vars, cancel, rep)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn run_build_step(
|
||||
step: &BuildStep,
|
||||
tools: &ToolchainExecs,
|
||||
step_flags: &str,
|
||||
vars: &StepVars,
|
||||
cancel: &Arc<AtomicBool>,
|
||||
rep: &mut dyn BuildReporter,
|
||||
) -> Result<(), String> {
|
||||
let input_pattern = expand_step_value(&step.input, "", vars);
|
||||
let inputs = expand_glob(&input_pattern)?;
|
||||
if inputs.is_empty() {
|
||||
return Ok(());
|
||||
}
|
||||
let needs_stem = step.output.contains("{stem}");
|
||||
if inputs.len() > 1 && !needs_stem {
|
||||
return Err(format!(
|
||||
"build.steps '{}' output must include {{stem}} for multiple inputs",
|
||||
step.name
|
||||
));
|
||||
}
|
||||
for input in inputs {
|
||||
if !input.is_file() {
|
||||
continue;
|
||||
}
|
||||
let stem = input.file_stem().and_then(|v| v.to_str()).unwrap_or("");
|
||||
let out_path = PathBuf::from(expand_step_value(&step.output, stem, vars));
|
||||
if !should_run_step(&input, &out_path) {
|
||||
continue;
|
||||
}
|
||||
if let Some(parent) = out_path.parent() {
|
||||
fs::create_dir_all(parent)
|
||||
.map_err(|err| format!("Failed to create step output dir: {err}"))?;
|
||||
}
|
||||
let cmd = substitute_step_cmd(&step.cmd, &input, &out_path, tools, step_flags, stem, vars);
|
||||
let status = run_shell_command(&cmd, cancel, rep)
|
||||
.map_err(|err| format!("Failed to run step '{}': {err}", step.name))?;
|
||||
if !status.success() {
|
||||
return Err(format!("Step '{}' failed", step.name));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn clean_generated_files(patterns: &[String]) -> Result<(), String> {
|
||||
for pattern in patterns {
|
||||
for path in expand_glob(pattern)? {
|
||||
if path.is_file() {
|
||||
let _ = fs::remove_file(&path);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub(crate) fn expand_glob(pattern: &str) -> Result<Vec<PathBuf>, String> {
|
||||
let mut out = Vec::new();
|
||||
let entries = glob(pattern).map_err(|err| format!("glob error: {err}"))?;
|
||||
for entry in entries {
|
||||
let path = entry.map_err(|err| format!("glob error: {err}"))?;
|
||||
out.push(path);
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
pub(crate) fn verify_expectations(patterns: &[String], vars: &StepVars) -> Result<(), String> {
|
||||
for pattern in patterns {
|
||||
let expanded = expand_step_value(pattern, "", vars);
|
||||
let matches = expand_glob(&expanded)?;
|
||||
if matches.is_empty() {
|
||||
return Err(format!("Expected artifact not found: {expanded}"));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn should_run_step(input: &Path, output: &Path) -> bool {
|
||||
let in_time = fs::metadata(input).and_then(|m| m.modified());
|
||||
let out_time = fs::metadata(output).and_then(|m| m.modified());
|
||||
match (in_time, out_time) {
|
||||
(Ok(i), Ok(o)) => i > o,
|
||||
(Ok(_), Err(_)) => true,
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
|
||||
fn substitute_step_cmd(
|
||||
template: &str,
|
||||
input: &Path,
|
||||
output: &Path,
|
||||
tools: &ToolchainExecs,
|
||||
step_flags: &str,
|
||||
stem: &str,
|
||||
vars: &StepVars,
|
||||
) -> String {
|
||||
let info = make_version_info(vars);
|
||||
let s = substitute_vars(template, &info, vars.profile, "");
|
||||
s.replace("{in}", &input.to_string_lossy())
|
||||
.replace("{out}", &output.to_string_lossy())
|
||||
.replace("{uic}", &tools.uic)
|
||||
.replace("{moc}", &tools.moc)
|
||||
.replace("{rcc}", &tools.rcc)
|
||||
.replace("{cflags}", step_flags)
|
||||
.replace("{stem}", stem)
|
||||
}
|
||||
|
||||
pub(crate) fn build_step_flags(
|
||||
cflags: &[String],
|
||||
include_dirs: &[String],
|
||||
compiler: &str,
|
||||
) -> String {
|
||||
let mut out = Vec::new();
|
||||
let msvc_style = is_msvc_compiler(compiler) || cflags.iter().any(|f| f.starts_with('/'));
|
||||
for flag in cflags {
|
||||
if flag.starts_with("-I") || flag.starts_with("-D") {
|
||||
out.push(flag.clone());
|
||||
}
|
||||
if flag.starts_with("/I") || flag.starts_with("/D") {
|
||||
out.push(flag.clone());
|
||||
}
|
||||
if msvc_style && flag.starts_with("-D") {
|
||||
out.push(format!("/D{}", flag.trim_start_matches("-D")));
|
||||
}
|
||||
}
|
||||
for dir in include_dirs {
|
||||
out.push(format!("-I{dir}"));
|
||||
if msvc_style {
|
||||
out.push(format!("/I{dir}"));
|
||||
}
|
||||
}
|
||||
out.sort();
|
||||
out.dedup();
|
||||
out.into_iter()
|
||||
.map(quote_step_arg)
|
||||
.collect::<Vec<_>>()
|
||||
.join(" ")
|
||||
}
|
||||
|
||||
fn quote_step_arg(arg: String) -> String {
|
||||
if !arg.chars().any(|c| c.is_whitespace() || c == '"') {
|
||||
return arg;
|
||||
}
|
||||
let escaped = arg.replace('"', "\\\"");
|
||||
format!("\"{escaped}\"")
|
||||
}
|
||||
|
||||
fn is_msvc_compiler(compiler: &str) -> bool {
|
||||
let lower = compiler.to_lowercase();
|
||||
lower.contains("cl.exe")
|
||||
|| lower == "cl"
|
||||
|| lower.contains("clang-cl")
|
||||
|| lower.contains("msvc")
|
||||
}
|
||||
|
||||
fn run_shell_command(
|
||||
cmd: &str,
|
||||
cancel: &Arc<AtomicBool>,
|
||||
rep: &mut dyn BuildReporter,
|
||||
) -> Result<std::process::ExitStatus, std::io::Error> {
|
||||
let mut child = if cfg!(target_os = "windows") {
|
||||
std::process::Command::new("cmd")
|
||||
.arg("/C")
|
||||
.arg(cmd)
|
||||
.stdout(std::process::Stdio::piped())
|
||||
.stderr(std::process::Stdio::piped())
|
||||
.spawn()
|
||||
} else {
|
||||
std::process::Command::new("sh")
|
||||
.arg("-c")
|
||||
.arg(cmd)
|
||||
.stdout(std::process::Stdio::piped())
|
||||
.stderr(std::process::Stdio::piped())
|
||||
.spawn()
|
||||
}?;
|
||||
|
||||
let stdout = child.stdout.take().unwrap();
|
||||
let stderr = child.stderr.take().unwrap();
|
||||
|
||||
use std::io::{BufRead, BufReader};
|
||||
use std::sync::mpsc;
|
||||
|
||||
let (tx, rx) = mpsc::channel();
|
||||
|
||||
let cancel_clone = cancel.clone();
|
||||
let tx_stdout = tx.clone();
|
||||
let stdout_thread = std::thread::spawn(move || {
|
||||
let reader = BufReader::new(stdout);
|
||||
for line in reader.lines() {
|
||||
if cancel_clone.load(std::sync::atomic::Ordering::SeqCst) {
|
||||
break;
|
||||
}
|
||||
if let Ok(line) = line {
|
||||
let _ = tx_stdout.send(("stdout", line));
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let cancel_clone = cancel.clone();
|
||||
let tx_stderr = tx.clone();
|
||||
let stderr_thread = std::thread::spawn(move || {
|
||||
let reader = BufReader::new(stderr);
|
||||
for line in reader.lines() {
|
||||
if cancel_clone.load(std::sync::atomic::Ordering::SeqCst) {
|
||||
break;
|
||||
}
|
||||
if let Ok(line) = line {
|
||||
let _ = tx_stderr.send(("stderr", line));
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let status = child.wait()?;
|
||||
let _ = stdout_thread.join();
|
||||
let _ = stderr_thread.join();
|
||||
|
||||
drop(tx);
|
||||
while let Ok((stream, text)) = rx.recv() {
|
||||
rep.on_event(BuildEvent::CompilerOutput {
|
||||
stream,
|
||||
text: &text,
|
||||
});
|
||||
}
|
||||
|
||||
Ok(status)
|
||||
}
|
||||
|
||||
pub(crate) fn build_steps_need_run(steps: &[BuildStep], vars: &StepVars) -> Result<bool, String> {
|
||||
for step in steps {
|
||||
let input_pattern = expand_step_value(&step.input, "", vars);
|
||||
let inputs = expand_glob(&input_pattern)?;
|
||||
if inputs.is_empty() {
|
||||
continue;
|
||||
}
|
||||
let needs_stem = step.output.contains("{stem}");
|
||||
if inputs.len() > 1 && !needs_stem {
|
||||
return Err(format!(
|
||||
"build.steps '{}' output must include {{stem}} for multiple inputs",
|
||||
step.name
|
||||
));
|
||||
}
|
||||
for input in inputs {
|
||||
if !input.is_file() {
|
||||
continue;
|
||||
}
|
||||
let stem = input.file_stem().and_then(|v| v.to_str()).unwrap_or("");
|
||||
let out_path = PathBuf::from(expand_step_value(&step.output, stem, vars));
|
||||
if should_run_step(&input, &out_path) {
|
||||
return Ok(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(false)
|
||||
}
|
||||
|
||||
fn make_version_info(vars: &StepVars) -> VersionInfo {
|
||||
VersionInfo {
|
||||
full: vars.version.to_string(),
|
||||
major: vars.version_major.to_string(),
|
||||
minor: vars.version_minor.to_string(),
|
||||
patch: vars.version_patch.to_string(),
|
||||
suffix: vars.version_suffix.to_string(),
|
||||
suffix_dash: vars.version_suffix_dash.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
fn expand_step_value(template: &str, stem: &str, vars: &StepVars) -> String {
|
||||
let info = make_version_info(vars);
|
||||
let s = substitute_vars(template, &info, vars.profile, "");
|
||||
s.replace("{stem}", stem)
|
||||
}
|
||||
Reference in New Issue
Block a user