feat: add native Qt support and dcr lint command; refactor architecture and integration tests

src/core/build_config.rs

@@ -138,6 +138,8 @@ pub struct BuildConfig {
     pub src_disable: Option<bool>,
     #[serde(default)]
     pub workspace_only: bool,
+    #[serde(default)]
+    pub qt: Option<bool>,
 }
 
 #[derive(Debug, Clone, Deserialize)]

src/core/builder/asm.rs

@@ -0,0 +1,170 @@
+use crate::core::builder::BuildContext;
+use crate::core::builder::common;
+use crate::platform;
+use std::path::Path;
+use std::process::Command;
+use std::time::Instant;
+
+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 archive_staticlib(ctx, &objects, start_time);
+    }
+
+    link_objects(ctx, &objects, 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)
+}
+
+fn archive_staticlib(
+    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);
+    }
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+
+    match cmd.status() {
+        Ok(status) if status.success() => Ok(common::elapsed_secs(start_time)),
+        Ok(_) => Err("Build failed".to_string()),
+        Err(err) => Err(format!("Build failed: {err}")),
+    }
+}
+
+fn link_objects(
+    ctx: &BuildContext,
+    objects: &[String],
+    start_time: Instant,
+) -> Result<f64, String> {
+    let mut cmd = Command::new(ctx.linker.unwrap_or("cc"));
+    if ctx.kind == "sharedlib" {
+        if cfg!(target_os = "macos") {
+            cmd.arg("-dynamiclib");
+        } else {
+            cmd.arg("-shared");
+        }
+    }
+
+    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 == "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);
+
+    if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
+        eprintln!("[dcr] {:?}", cmd);
+    }
+
+    match cmd.status() {
+        Ok(status) if status.success() => Ok(common::elapsed_secs(start_time)),
+        Ok(_) => Err("Build failed".to_string()),
+        Err(err) => Err(format!("Build failed: {err}")),
+    }
+}

src/core/builder/common.rs

@@ -19,6 +19,7 @@ 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();
 
@@ -164,6 +165,36 @@ 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()) {
+        let lang = part.to_lowercase();
+        match lang.as_str() {
+            "c" => out.extend(["c"]),
+            "c++" | "cpp" | "cxx" => out.extend(["cpp", "cxx", "cc"]),
+            "asm" => out.extend(["s", "S", "asm"]),
+            _ => {}
+        }
+    }
+    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,
@@ -796,4 +827,44 @@ mod tests {
             "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);
+    }
 }

src/core/builder/fasm.rs

@@ -0,0 +1,47 @@
+use crate::core::builder::BuildContext;
+use crate::core::builder::asm;
+use crate::core::builder::common;
+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 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)
+}

src/core/builder/gas.rs

@@ -16,121 +16,17 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use crate::core::builder::BuildContext;
+use crate::core::builder::asm;
 use crate::core::builder::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 lang = ctx.language.to_lowercase();
-    if lang.split(',').any(|p| p.trim() != "asm") {
-        return Err("GAS backend requires build.language = \"asm\"".to_string());
-    }
-    let assembler = if ctx.compiler.is_empty() {
-        "as"
-    } else {
-        ctx.compiler
-    };
-    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(assembler, &sources, &obj_dir, ctx, "o")?;
-
-    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 = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-            return Ok(elapsed);
-        }
-        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);
-        }
-        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
-            eprintln!("[dcr] {:?}", cmd);
-        }
-        match cmd.status() {
-            Ok(status) if status.success() => {
-                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-                return Ok(elapsed);
-            }
-            Ok(_) => return Err("Build failed".to_string()),
-            Err(err) => return Err(format!("Build failed: {err}")),
-        }
-    }
-
-    let mut cmd = Command::new(ctx.linker.unwrap_or("cc"));
-    if ctx.kind == "sharedlib" {
-        if cfg!(target_os = "macos") {
-            cmd.arg("-dynamiclib");
-        } else {
-            cmd.arg("-shared");
-        }
-    }
-    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 == "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) {
-        let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-        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 = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-            Ok(elapsed)
-        }
-        Ok(_) => Err("Build failed".to_string()),
-        Err(err) => Err(format!("Build failed: {err}")),
-    }
+    asm::build_assembly(ctx, "GAS", "as", &["s"], build_object)
 }
 
 pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
-    // GAS handles only lowercase .s files
     common::collect_sources(
         ctx.source_roots,
         &["s"],
@@ -139,27 +35,6 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
     )
 }
 
-fn build_objects(
-    assembler: &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(assembler, &sources[i], &objects[i], ctx),
-        ctx.codegen_units,
-    )?;
-
-    Ok(objects)
-}
-
 fn build_object(
     assembler: &str,
     source: &str,

src/core/builder/llvm_ir.rs

@@ -0,0 +1,43 @@
+use crate::core::builder::BuildContext;
+use crate::core::builder::asm;
+use crate::core::builder::common;
+use std::fs;
+use std::path::Path;
+use std::process::Command;
+
+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)
+}

src/core/builder/masm.rs

@@ -0,0 +1,51 @@
+use crate::core::builder::BuildContext;
+use crate::core::builder::asm;
+use crate::core::builder::common;
+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 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)
+}

src/core/builder/mod.rs

@@ -15,10 +15,15 @@
 // 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 common;
+pub mod fasm;
 pub mod gas;
+pub mod llvm_ir;
+pub mod masm;
 pub mod msvc;
 pub mod nasm;
+pub mod qt;
 pub mod unix_cc;
 
 pub struct BuildContext<'a> {
@@ -34,6 +39,9 @@ pub struct BuildContext<'a> {
     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,
@@ -49,6 +57,7 @@ pub struct BuildContext<'a> {
     pub output_filename: Option<&'a str>,
     pub output_extension: Option<&'a str>,
     pub verbose: bool,
+    pub qt: bool,
 }
 
 pub fn build(ctx: &BuildContext) -> Result<f64, String> {
@@ -65,9 +74,18 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     if compiler == "as" || compiler.contains("gas") {
         return gas::build(ctx);
     }
+    if compiler.contains("llc") {
+        return llvm_ir::build(ctx);
+    }
+    if compiler.contains("fasm") {
+        return fasm::build(ctx);
+    }
     if compiler.contains("nasm") {
         return nasm::build(ctx);
     }
+    if compiler == "ml" || compiler == "ml64" || compiler.contains("masm") {
+        return masm::build(ctx);
+    }
     if compiler == "cl" || compiler.contains("msvc") {
         return msvc::build(ctx);
     }
@@ -90,8 +108,17 @@ pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
     if compiler == "as" || compiler.contains("gas") {
         return gas::collect_sources(ctx);
     }
+    if compiler.contains("llc") {
+        return llvm_ir::collect_sources(ctx);
+    }
+    if compiler.contains("fasm") {
+        return fasm::collect_sources(ctx);
+    }
     if compiler.contains("nasm") {
         return nasm::collect_sources(ctx);
     }
+    if compiler == "ml" || compiler == "ml64" || compiler.contains("masm") {
+        return masm::collect_sources(ctx);
+    }
     unix_cc::collect_sources(ctx)
 }

src/core/builder/msvc.rs

@@ -44,7 +44,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     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 = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            let elapsed = common::elapsed_secs(start_time);
             return Ok(elapsed);
         }
         let mut cmd = Command::new(ctx.archiver.unwrap_or("lib"));
@@ -57,7 +57,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         }
         match cmd.status() {
             Ok(status) if status.success() => {
-                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                let elapsed = common::elapsed_secs(start_time);
                 return Ok(elapsed);
             }
             Ok(_) => return Err("Build failed".to_string()),
@@ -123,17 +123,17 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     };
 
     if !common::needs_link(&objects, &out_path) {
-        let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+        let elapsed = common::elapsed_secs(start_time);
         return Ok(elapsed);
     }
-    cmd.arg(format!("/Fe:{out_path}"));
+    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 = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            let elapsed = common::elapsed_secs(start_time);
             Ok(elapsed)
         }
         Ok(_) => Err("Build failed".to_string()),
@@ -151,21 +151,8 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
     )
 }
 
-fn source_extensions(language: &str) -> Vec<&str> {
-    let mut out = Vec::new();
-    for part in language.split(',').map(|s| s.trim()) {
-        let lang = part.to_lowercase();
-        match lang.as_str() {
-            "c" => out.extend(["c"]),
-            "c++" | "cpp" | "cxx" => out.extend(["cpp", "cxx", "cc"]),
-            "asm" => {}
-            _ => {}
-        }
-    }
-    if out.is_empty() {
-        out.extend(["c"]);
-    }
-    out
+fn source_extensions(language: &str) -> Vec<&'static str> {
+    crate::core::builder::common::source_extensions(language)
 }
 
 fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String> {

src/core/builder/nasm.rs

@@ -16,117 +16,14 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 use crate::core::builder::BuildContext;
+use crate::core::builder::asm;
 use crate::core::builder::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 lang = ctx.language.to_lowercase();
-    if lang.split(',').any(|p| p.trim() != "asm") {
-        return Err("NASM backend requires build.language = \"asm\"".to_string());
-    }
-    let assembler = if ctx.compiler.is_empty() {
-        "nasm"
-    } else {
-        ctx.compiler
-    };
-    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(assembler, &sources, &obj_dir, ctx, "o")?;
-
-    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 = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-            return Ok(elapsed);
-        }
-        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);
-        }
-        if ctx.verbose || std::env::var("DCR_DEBUG").is_ok() {
-            eprintln!("[dcr] {:?}", cmd);
-        }
-        match cmd.status() {
-            Ok(status) if status.success() => {
-                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-                return Ok(elapsed);
-            }
-            Ok(_) => return Err("Build failed".to_string()),
-            Err(err) => return Err(format!("Build failed: {err}")),
-        }
-    }
-
-    let mut cmd = Command::new(ctx.linker.unwrap_or("cc"));
-    if ctx.kind == "sharedlib" {
-        if cfg!(target_os = "macos") {
-            cmd.arg("-dynamiclib");
-        } else {
-            cmd.arg("-shared");
-        }
-    }
-    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 == "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) {
-        let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-        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 = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
-            Ok(elapsed)
-        }
-        Ok(_) => Err("Build failed".to_string()),
-        Err(err) => Err(format!("Build failed: {err}")),
-    }
+    asm::build_assembly(ctx, "NASM", "nasm", &["asm", "s"], build_object)
 }
 
 pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
@@ -139,34 +36,10 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
     )
 }
 
-fn build_objects(
-    assembler: &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();
-
-    let format = nasm_format(ctx.platform);
-
-    common::parallel_build(
-        sources.len(),
-        |i| build_object(assembler, &sources[i], &objects[i], format, ctx),
-        ctx.codegen_units,
-    )?;
-
-    Ok(objects)
-}
-
 fn build_object(
     assembler: &str,
     source: &str,
     obj_path: &str,
-    format: &str,
     ctx: &BuildContext,
 ) -> Result<(), String> {
     if let Some(parent) = Path::new(obj_path).parent() {
@@ -177,6 +50,8 @@ fn build_object(
         return Ok(());
     }
 
+    let format = nasm_format(ctx.platform);
+
     let mut cmd = Command::new(assembler);
     cmd.arg("-f")
         .arg(format)

src/core/builder/qt.rs

@@ -0,0 +1,141 @@
+// 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::builder::BuildContext;
+use crate::core::builder::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,
+    )?;
+
+    // Fetch Qt system include paths and defines for MOC
+    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() {
+                // Pass both -I and -D flags to moc
+                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();
+
+                        // Add Qt system cflags (includes + defines)
+                        for arg in &qt_moc_args {
+                            moc_args.push(arg.as_str());
+                        }
+
+                        // Add project include paths
+                        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)),
+    }
+}

src/core/builder/unix_cc.rs

@@ -20,7 +20,7 @@ use crate::core::builder::common;
 use crate::platform;
 use crate::utils::build::is_bare_metal_target;
 use std::fs;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::Instant;
 
@@ -31,23 +31,34 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let extensions = source_extensions(ctx.language);
-    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(compiler, &sources, &obj_dir, ctx, "o")?;
+    let qt_include_path = if ctx.qt {
+        crate::core::builder::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" {
         let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
         if !common::needs_link(&objects, &lib_path) {
-            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            let elapsed = common::elapsed_secs(start_time);
             return Ok(elapsed);
         }
         let mut cmd = Command::new(ctx.archiver.unwrap_or("ar"));
@@ -60,7 +71,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         }
         match cmd.status() {
             Ok(status) if status.success() => {
-                let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+                let elapsed = common::elapsed_secs(start_time);
                 return Ok(elapsed);
             }
             Ok(_) => return Err("Build failed".to_string()),
@@ -116,7 +127,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     };
 
     if !common::needs_link(&objects, &out_path) {
-        let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+        let elapsed = common::elapsed_secs(start_time);
         return Ok(elapsed);
     }
     cmd.arg("-o").arg(out_path);
@@ -126,7 +137,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
     match cmd.status() {
         Ok(status) if status.success() => {
-            let elapsed = ((start_time.elapsed().as_secs_f64() * 100.0).trunc()) / 100.0;
+            let elapsed = common::elapsed_secs(start_time);
             Ok(elapsed)
         }
         Ok(_) => Err("Build failed".to_string()),
@@ -144,36 +155,12 @@ pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String>
     )
 }
 
-fn source_extensions(language: &str) -> Vec<&str> {
-    let mut out = Vec::new();
-    for part in language.split(',').map(|s| s.trim()) {
-        let lang = part.to_lowercase();
-        match lang.as_str() {
-            "c" => out.extend(["c"]),
-            "c++" | "cpp" | "cxx" => out.extend(["cpp", "cxx", "cc"]),
-            "asm" => out.extend(["s", "S", "asm"]),
-            _ => {}
-        }
-    }
-    if out.is_empty() {
-        out.extend(["c"]);
-    }
-    out
+fn source_extensions(language: &str) -> Vec<&'static str> {
+    crate::core::builder::common::source_extensions(language)
 }
 
 fn default_flags(profile: &str) -> &'static [&'static str] {
-    match profile {
-        "release" => &["-O3", "-DNDEBUG"],
-        "debug" => &[
-            "-O0",
-            "-g",
-            "-Wall",
-            "-Wextra",
-            "-fno-omit-frame-pointer",
-            "-DDCR_DEBUG",
-        ],
-        _ => &[],
-    }
+    crate::utils::build::default_profile_flags(profile)
 }
 
 fn build_objects(
@@ -182,6 +169,7 @@ fn build_objects(
     obj_dir: &Path,
     ctx: &BuildContext,
     obj_ext: &str,
+    qt_include_dir: Option<PathBuf>,
 ) -> Result<Vec<String>, String> {
     let objects: Vec<String> = sources
         .iter()
@@ -190,7 +178,15 @@ fn build_objects(
 
     common::parallel_build(
         sources.len(),
-        |i| build_object(compiler, &sources[i], &objects[i], ctx),
+        |i| {
+            build_object(
+                compiler,
+                &sources[i],
+                &objects[i],
+                ctx,
+                qt_include_dir.as_deref(),
+            )
+        },
         ctx.codegen_units,
     )?;
 
@@ -202,6 +198,7 @@ fn build_object(
     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}"))?;
@@ -276,6 +273,10 @@ fn build_object(
         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);
 
@@ -287,10 +288,5 @@ fn build_object(
 }
 
 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,
-    }
+    crate::core::builder::common::asm_lang_flag(source)
 }

src/core/deps/common.rs

@@ -1,128 +1,6 @@
-// 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/>.
-
-#[allow(dead_code)]
-use std::fs;
-use std::path::{Path, PathBuf};
-
-#[derive(Debug, Clone)]
-#[allow(dead_code)]
-pub enum DepSource {
-    Path(String),
-    Git {
-        url: String,
-        branch: Option<String>,
-        tag: Option<String>,
-        rev: Option<String>,
-    },
-    Registry {
-        version: String,
-        features: Option<Vec<String>>,
-    },
-}
-
-#[allow(dead_code)]
-#[derive(Debug, Clone)]
-pub struct DepSpec {
-    pub name: String,
-    pub source: DepSource,
-    pub include_raw: Option<Vec<String>>,
-    pub lib_raw: Option<Vec<String>>,
-    pub libs_raw: Option<Vec<String>>,
-}
-
 #[derive(Debug, Clone, Default)]
 pub struct ResolvedDeps {
     pub include_dirs: Vec<String>,
     pub lib_dirs: Vec<String>,
     pub libs: Vec<String>,
 }
-
-#[allow(dead_code)]
-pub fn resolve_path(project_root: &Path, raw: &str) -> Result<PathBuf, String> {
-    let p = Path::new(raw);
-    let full = if p.is_absolute() {
-        p.to_path_buf()
-    } else {
-        project_root.join(p)
-    };
-    Ok(full)
-}
-
-#[allow(dead_code)]
-pub fn resolve_paths(
-    base: &Path,
-    raw: Option<&[String]>,
-    defaults: &[&str],
-    profile: &str,
-) -> Result<Vec<PathBuf>, String> {
-    let mut out = Vec::new();
-    if let Some(raw) = raw {
-        for r in raw {
-            let expanded = expand_profile(r, profile);
-            let p = Path::new(&expanded);
-            let full = if p.is_absolute() {
-                p.to_path_buf()
-            } else {
-                base.join(p)
-            };
-            if !full.exists() {
-                return Err(format!("Path does not exist: {}", full.display()));
-            }
-            out.push(full);
-        }
-        return Ok(out);
-    }
-
-    for d in defaults {
-        let candidate = base.join(d);
-        if candidate.exists() {
-            out.push(candidate);
-        }
-    }
-    Ok(out)
-}
-
-#[allow(dead_code)]
-pub fn expand_profile(raw: &str, profile: &str) -> String {
-    raw.replace("{profile}", profile)
-}
-
-#[allow(dead_code)]
-pub fn sync_dep_dir(src: &Path, dst: &Path) -> std::io::Result<()> {
-    if dst.exists() {
-        fs::remove_dir_all(dst)?;
-    }
-    copy_dir_all(src, dst)
-}
-
-#[allow(dead_code)]
-pub fn copy_dir_all(src: &Path, dst: &Path) -> std::io::Result<()> {
-    fs::create_dir_all(dst)?;
-    for entry in fs::read_dir(src)? {
-        let entry = entry?;
-        let ty = entry.file_type()?;
-        let from = entry.path();
-        let to = dst.join(entry.file_name());
-        if ty.is_dir() {
-            copy_dir_all(&from, &to)?;
-        } else {
-            fs::copy(&from, &to)?;
-        }
-    }
-    Ok(())
-}

src/core/deps/git.rs

@@ -1,33 +0,0 @@
-// 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::path::Path;
-
-#[allow(dead_code)]
-pub fn fetch_git_dep(
-    url: &str,
-    target_dir: &Path,
-    branch: Option<&str>,
-    tag: Option<&str>,
-    rev: Option<&str>,
-) -> Result<(), String> {
-    if target_dir.exists() {
-        return Ok(());
-    }
-
-    crate::utils::git::git_clone_and_checkout(url, target_dir, branch, tag, rev)
-}

src/core/deps/lock.rs

@@ -15,10 +15,8 @@
 // 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 sha2::{Digest, Sha256};
 use std::fs;
 use std::path::Path;
-use toml::Value;
 
 #[derive(Debug, Clone)]
 pub struct DepLock {
@@ -73,65 +71,3 @@ fn quote_list(items: &[String]) -> String {
 fn escape_value(input: &str) -> String {
     input.replace('\\', "\\\\").replace('"', "\\\"")
 }
-
-#[allow(dead_code)]
-pub fn read_dep_version(dep_path: &Path) -> Option<String> {
-    let path = dep_path.join("dcr.toml");
-    let content = fs::read_to_string(path).ok()?;
-    let value: Value = content.parse().ok()?;
-    value
-        .get("package")
-        .and_then(|v| v.as_table())
-        .and_then(|t| t.get("version"))
-        .and_then(|v| v.as_str())
-        .map(|s| s.to_string())
-}
-
-#[allow(dead_code)]
-pub fn compute_checksum(root: &Path) -> Result<String, String> {
-    let mut files = Vec::new();
-    collect_files(root, root, &mut files)?;
-    files.sort();
-    let mut hasher = Sha256::new();
-    for rel in files {
-        hasher.update(rel.as_bytes());
-        let data =
-            fs::read(root.join(&rel)).map_err(|err| format!("failed to read {}: {err}", rel))?;
-        hasher.update(&data);
-    }
-    let hash = hasher.finalize();
-    Ok(to_hex(&hash))
-}
-
-#[allow(dead_code)]
-fn collect_files(root: &Path, dir: &Path, out: &mut Vec<String>) -> Result<(), String> {
-    for entry in fs::read_dir(dir).map_err(|err| format!("read_dir failed: {err}"))? {
-        let entry = entry.map_err(|err| format!("read_dir failed: {err}"))?;
-        let path = entry.path();
-        let name = entry.file_name();
-        let name_str = name.to_string_lossy();
-        if name_str == "target" {
-            continue;
-        }
-        if path.is_dir() {
-            collect_files(root, &path, out)?;
-        } else if path.is_file() {
-            let rel = path
-                .strip_prefix(root)
-                .unwrap_or(&path)
-                .to_string_lossy()
-                .to_string();
-            out.push(rel);
-        }
-    }
-    Ok(())
-}
-
-#[allow(dead_code)]
-fn to_hex(bytes: &[u8]) -> String {
-    let mut out = String::with_capacity(bytes.len() * 2);
-    for b in bytes {
-        out.push_str(&format!("{:02x}", b));
-    }
-    out
-}

src/core/deps/mod.rs

@@ -16,11 +16,10 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 pub mod common;
-pub mod git;
 pub mod lock;
 pub mod register;
 
-use crate::core::config::Config;
+use crate::core::build_config::Config;
 use crate::core::deps::common::ResolvedDeps;
 use crate::core::deps::lock::{DepLock, write_lock};
 use std::path::Path;

src/core/deps/register.rs

@@ -33,13 +33,7 @@ pub struct DcrConfig {
 }
 
 fn home_dir() -> Option<PathBuf> {
-    if let Ok(home) = std::env::var("HOME") {
-        return Some(PathBuf::from(home));
-    }
-    if let Ok(profile) = std::env::var("USERPROFILE") {
-        return Some(PathBuf::from(profile));
-    }
-    None
+    crate::utils::fs::home_dir()
 }
 
 fn dcr_config_dir() -> Option<PathBuf> {

src/core/mod.rs

@@ -15,8 +15,8 @@
 // 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 build_config;
 pub mod builder;
-pub mod config;
 pub mod deps;
 pub mod registry;
 pub mod runner;

src/core/registry.rs

@@ -38,13 +38,7 @@ pub struct RegistryManager {
 }
 
 fn home_dir() -> Option<PathBuf> {
-    if let Ok(home) = std::env::var("HOME") {
-        return Some(PathBuf::from(home));
-    }
-    if let Ok(profile) = std::env::var("USERPROFILE") {
-        return Some(PathBuf::from(profile));
-    }
-    None
+    crate::utils::fs::home_dir()
 }
 
 impl RegistryManager {

src/core/workspace.rs

@@ -15,7 +15,7 @@
 // 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::config::Config;
+use crate::core::build_config::Config;
 use crate::utils::build::normalize_target_os;
 use std::collections::{HashMap, HashSet};
 use std::path::{Path, PathBuf};