feat: Refactor builder modules by consolidating Unix C/C++ compilers, extracting common logic, enhancing MSVC with dependency tracking, and adding new CLI error tests.

src/core/builder/common.rs

@@ -0,0 +1,395 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+
+pub fn collect_sources(
+    extensions: &[&str],
+    exclude_dirs: &[PathBuf],
+) -> Result<Vec<String>, String> {
+    let mut sources = Vec::new();
+    collect_sources_rec("./src", extensions, &mut sources, exclude_dirs)?;
+    sources.sort();
+    if sources.is_empty() {
+        return Err("No source files found in ./src".to_string());
+    }
+    Ok(sources)
+}
+
+fn collect_sources_rec(
+    dir: &str,
+    extensions: &[&str],
+    out: &mut Vec<String>,
+    exclude_dirs: &[PathBuf],
+) -> Result<(), String> {
+    let dir_path = Path::new(dir);
+    let full_dir = if dir_path.is_absolute() {
+        dir_path.to_path_buf()
+    } else {
+        std::env::current_dir()
+            .map_err(|err| format!("src dir error: {err}"))?
+            .join(dir_path)
+    };
+    if is_excluded(&full_dir, exclude_dirs) {
+        return Ok(());
+    }
+    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
+    for entry in entries {
+        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
+        let path = entry.path();
+        if path.is_dir() {
+            if is_excluded(&path, exclude_dirs) {
+                continue;
+            }
+            collect_sources_rec(&path.to_string_lossy(), extensions, out, exclude_dirs)?;
+            continue;
+        }
+        if !path.is_file() {
+            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]) -> bool {
+    exclude_dirs.iter().any(|dir| path.starts_with(dir))
+}
+
+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 rel = src_path
+        .strip_prefix("./src")
+        .or_else(|_| src_path.strip_prefix("src"))
+        .unwrap_or(src_path);
+    let mut out = obj_dir.join(rel);
+    out.set_extension(obj_ext.trim_start_matches('.'));
+    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; // Missing dependency triggers rebuild
+            }
+        }
+    }
+    false
+}
+
+fn parse_d_file(content: &str) -> Vec<String> {
+    let mut deps = Vec::new();
+    let text = content.replace("\\\n", " ").replace("\\\r\n", " ");
+    let mut target_end = 0;
+    let chars: Vec<char> = text.chars().collect();
+    for i in 0..chars.len() {
+        if chars[i] == ':' {
+            if i == 1 && chars[0].is_ascii_alphabetic() && i + 1 < chars.len() && (chars[i+1] == '\\' || chars[i+1] == '/') {
+                continue; // Windows drive letter
+            }
+            target_end = i + 1;
+            break;
+        }
+    }
+    
+    let deps_str = if target_end > 0 { &text[target_end..] } else { &text };
+    
+    let mut current_path = String::new();
+    let mut in_escape = false;
+    
+    for c in deps_str.chars() {
+        if in_escape {
+            if c != '\n' && c != '\r' {
+                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::atomic::{AtomicUsize, Ordering};
+
+    static TEST_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+    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
+    }
+
+    #[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.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.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.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.obj");
+    }
+
+    #[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();
+        // Sleep briefly to ensure mtime difference
+        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 excluded = vec![PathBuf::from("/project/src/vendor")];
+        assert!(is_excluded(Path::new("/project/src/vendor"), &excluded));
+        assert!(is_excluded(
+            Path::new("/project/src/vendor/lib.c"),
+            &excluded
+        ));
+    }
+
+    #[test]
+    fn is_excluded_no_match() {
+        let excluded = vec![PathBuf::from("/project/src/vendor")];
+        assert!(!is_excluded(Path::new("/project/src/main.c"), &excluded));
+        assert!(!is_excluded(Path::new("/other/vendor"), &excluded));
+    }
+
+    #[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 prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let result = collect_sources(&["c"], &[]);
+        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 prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let result = collect_sources(&["cpp", "cxx", "cc"], &[]);
+        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 prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let result = collect_sources(&["c"], &[]);
+        std::env::set_current_dir(prev).unwrap();
+
+        assert!(result.is_err(), "empty src should return error");
+    }
+
+    #[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 prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let result = collect_sources(&["c"], &exclude);
+        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 prev = std::env::current_dir().unwrap();
+        std::env::set_current_dir(&dir).unwrap();
+        let result = collect_sources(&["c"], &[]);
+        std::env::set_current_dir(prev).unwrap();
+
+        let sources = result.expect("should find sources");
+        assert_eq!(sources.len(), 2);
+    }
+
+    #[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");
+    }
+}
+

src/core/builder/gas.rs

@@ -1,7 +1,8 @@
 use crate::core::builder::BuildContext;
+use crate::core::builder::common;
 use crate::platform;
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::process::Command;
 use std::time::Instant;
 
@@ -15,7 +16,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
+    let sources = collect_sources(ctx)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
 
@@ -82,76 +83,9 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-pub(crate) fn collect_sources(
-    language: &str,
-    exclude_dirs: &[PathBuf],
-) -> Result<Vec<String>, String> {
-    let lang = language.to_lowercase();
-    let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
-    sources.sort();
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
-    }
-    Ok(sources)
-}
-
-fn collect_sources_rec(
-    dir: &str,
-    lang: &str,
-    out: &mut Vec<String>,
-    exclude_dirs: &[PathBuf],
-) -> Result<(), String> {
-    let dir_path = Path::new(dir);
-    let full_dir = if dir_path.is_absolute() {
-        dir_path.to_path_buf()
-    } else {
-        std::env::current_dir()
-            .map_err(|err| format!("src dir error: {err}"))?
-            .join(dir_path)
-    };
-    if is_excluded(&full_dir, exclude_dirs) {
-        return Ok(());
-    }
-    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            if is_excluded(&path, exclude_dirs) {
-                continue;
-            }
-            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or("");
-        let ext = ext_raw.to_lowercase();
-        let file = normalize_source_path(&path);
-        let allowed = lang == "asm" && ext == "s" && ext_raw == "s";
-        if allowed {
-            out.push(file);
-        }
-    }
-    Ok(())
-}
-
-fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
-    exclude_dirs.iter().any(|dir| path.starts_with(dir))
-}
-
-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(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    // GAS handles only lowercase .s files
+    common::collect_sources(&["s"], ctx.exclude_dirs)
 }
 
 fn build_objects(
@@ -163,11 +97,11 @@ fn build_objects(
 ) -> Result<Vec<String>, String> {
     let mut objects = Vec::new();
     for source in sources {
-        let obj_path = object_path(obj_dir, source, obj_ext);
+        let obj_path = common::object_path(obj_dir, source, obj_ext);
         if let Some(parent) = Path::new(&obj_path).parent() {
             fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
         }
-        if needs_rebuild(source, &obj_path) {
+        if common::needs_rebuild(source, &obj_path) {
             let mut cmd = Command::new(assembler);
             cmd.arg(source).arg("-o").arg(&obj_path);
             for flag in ctx.cflags {
@@ -183,24 +117,3 @@ fn build_objects(
     }
     Ok(objects)
 }
-
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
-    let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
-    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
-    out.to_string_lossy().to_string()
-}
-
-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());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
-    }
-}

src/core/builder/gcc.rs

@@ -1,250 +0,0 @@
-use crate::core::builder::BuildContext;
-use crate::platform;
-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 sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
-    let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
-    let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
-
-    if ctx.kind == "staticlib" {
-        let lib_path = platform::lib_path(ctx.profile, ctx.project_name, ctx.target_dir);
-        let mut cmd = Command::new(ctx.archiver.unwrap_or("ar"));
-        cmd.arg("rcs").arg(&lib_path);
-        for obj in &objects {
-            cmd.arg(obj);
-        }
-        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(compiler));
-    if ctx.kind == "sharedlib" {
-        if cfg!(target_os = "macos") {
-            cmd.arg("-dynamiclib");
-        } else {
-            cmd.arg("-shared");
-        }
-    }
-    for obj in &objects {
-        cmd.arg(obj);
-    }
-    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!("-L{dir}"));
-    }
-    for lib in ctx.libs {
-        cmd.arg(format!("-l{lib}"));
-    }
-    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 {
-        platform::bin_path(ctx.profile, ctx.project_name, ctx.target_dir)
-    };
-    cmd.arg("-o").arg(out_path);
-
-    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}")),
-    }
-}
-
-pub(crate) fn collect_sources(
-    language: &str,
-    exclude_dirs: &[PathBuf],
-) -> Result<Vec<String>, String> {
-    let lang = language.to_lowercase();
-    let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
-    sources.sort();
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
-    }
-    Ok(sources)
-}
-
-fn collect_sources_rec(
-    dir: &str,
-    lang: &str,
-    out: &mut Vec<String>,
-    exclude_dirs: &[PathBuf],
-) -> Result<(), String> {
-    let dir_path = Path::new(dir);
-    let full_dir = if dir_path.is_absolute() {
-        dir_path.to_path_buf()
-    } else {
-        std::env::current_dir()
-            .map_err(|err| format!("src dir error: {err}"))?
-            .join(dir_path)
-    };
-    if is_excluded(&full_dir, exclude_dirs) {
-        return Ok(());
-    }
-    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            if is_excluded(&path, exclude_dirs) {
-                continue;
-            }
-            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext = path
-            .extension()
-            .and_then(|v| v.to_str())
-            .unwrap_or("")
-            .to_lowercase();
-        let file = normalize_source_path(&path);
-        let allowed = (lang == "c" && ext == "c")
-            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
-                && (ext == "cpp" || ext == "cxx" || ext == "cc"))
-            || (lang == "asm" && (ext == "s" || ext == "asm"));
-        if allowed {
-            out.push(file);
-        }
-    }
-    Ok(())
-}
-
-fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
-    exclude_dirs.iter().any(|dir| path.starts_with(dir))
-}
-
-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()
-}
-
-fn default_flags(profile: &str) -> &'static [&'static str] {
-    match profile {
-        "release" => &["-O3", "-DNDEBUG", "-march=native"],
-        "debug" => &[
-            "-O0",
-            "-g",
-            "-Wall",
-            "-Wextra",
-            "-fno-omit-frame-pointer",
-            "-DDEBUG",
-        ],
-        _ => &[],
-    }
-}
-
-fn build_objects(
-    compiler: &str,
-    sources: &[String],
-    obj_dir: &Path,
-    ctx: &BuildContext,
-    obj_ext: &str,
-) -> Result<Vec<String>, String> {
-    let mut objects = Vec::new();
-    for source in sources {
-        let obj_path = object_path(obj_dir, source, obj_ext);
-        if let Some(parent) = Path::new(&obj_path).parent() {
-            fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
-        }
-        if needs_rebuild(source, &obj_path) {
-            let mut cmd = Command::new(compiler);
-            cmd.arg("-c").arg(source).arg("-o").arg(&obj_path);
-            if ctx.kind == "sharedlib" {
-                cmd.arg("-fPIC");
-            }
-            if let Some(flag) = asm_lang_flag(source) {
-                cmd.arg("-x").arg(flag);
-            }
-            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" {
-                cmd.arg(format!("-std={}", ctx.standard));
-            }
-            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}"));
-            }
-            match cmd.status() {
-                Ok(status) if status.success() => {}
-                Ok(_) => return Err("Build failed".to_string()),
-                Err(err) => return Err(format!("Build failed: {err}")),
-            }
-        }
-        objects.push(obj_path);
-    }
-    Ok(objects)
-}
-
-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,
-    }
-}
-
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
-    let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
-    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
-    out.to_string_lossy().to_string()
-}
-
-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());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
-    }
-}

src/core/builder/mod.rs

@@ -1,8 +1,8 @@
-pub mod clang;
+pub mod common;
 pub mod gas;
-pub mod gcc;
 pub mod msvc;
 pub mod nasm;
+pub mod unix_cc;
 
 pub struct BuildContext<'a> {
     pub profile: &'a str,
@@ -34,37 +34,22 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     if compiler.contains("nasm") {
         return nasm::build(ctx);
     }
-    if compiler.contains("gcc") || compiler.contains("g++") {
-        return gcc::build(ctx);
-    }
-    if compiler.contains("clang") || compiler.contains("clang++") {
-        return clang::build(ctx);
-    }
     if compiler == "cl" || compiler.contains("msvc") {
         return msvc::build(ctx);
     }
-    clang::build(ctx)
+    unix_cc::build(ctx)
 }
 
 pub fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
     let compiler = ctx.compiler.to_lowercase();
-    if compiler.contains("clang-cl") {
-        return msvc::collect_sources(ctx.language, ctx.exclude_dirs);
+    if compiler.contains("clang-cl") || compiler == "cl" || compiler.contains("msvc") {
+        return msvc::collect_sources(ctx);
     }
     if compiler == "as" || compiler.contains("gas") {
-        return gas::collect_sources(ctx.language, ctx.exclude_dirs);
+        return gas::collect_sources(ctx);
     }
     if compiler.contains("nasm") {
-        return nasm::collect_sources(ctx.language, ctx.exclude_dirs);
+        return nasm::collect_sources(ctx);
     }
-    if compiler.contains("gcc") || compiler.contains("g++") {
-        return gcc::collect_sources(ctx.language, ctx.exclude_dirs);
-    }
-    if compiler.contains("clang") || compiler.contains("clang++") {
-        return clang::collect_sources(ctx.language, ctx.exclude_dirs);
-    }
-    if compiler == "cl" || compiler.contains("msvc") {
-        return msvc::collect_sources(ctx.language, ctx.exclude_dirs);
-    }
-    clang::collect_sources(ctx.language, ctx.exclude_dirs)
+    unix_cc::collect_sources(ctx)
 }

src/core/builder/msvc.rs

@@ -1,7 +1,8 @@
 use crate::core::builder::BuildContext;
+use crate::core::builder::common;
 use crate::platform;
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::process::Command;
 use std::time::Instant;
 
@@ -15,7 +16,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         return Err("MSVC backend does not support build.language = \"asm\"".to_string());
     }
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
+    let sources = collect_sources(ctx)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(compiler, &sources, &obj_dir, ctx, "obj")?;
 
@@ -100,82 +101,18 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-pub(crate) fn collect_sources(
-    language: &str,
-    exclude_dirs: &[PathBuf],
-) -> Result<Vec<String>, String> {
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    let extensions = source_extensions(ctx.language);
+    common::collect_sources(&extensions, ctx.exclude_dirs)
+}
+
+fn source_extensions(language: &str) -> Vec<&str> {
     let lang = language.to_lowercase();
-    let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
-    sources.sort();
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
+    match lang.as_str() {
+        "c" => vec!["c"],
+        "c++" | "cpp" | "cxx" => vec!["cpp", "cxx", "cc"],
+        _ => vec!["c"],
     }
-    Ok(sources)
-}
-
-fn collect_sources_rec(
-    dir: &str,
-    lang: &str,
-    out: &mut Vec<String>,
-    exclude_dirs: &[PathBuf],
-) -> Result<(), String> {
-    let dir_path = Path::new(dir);
-    let full_dir = if dir_path.is_absolute() {
-        dir_path.to_path_buf()
-    } else {
-        std::env::current_dir()
-            .map_err(|err| format!("src dir error: {err}"))?
-            .join(dir_path)
-    };
-    if is_excluded(&full_dir, exclude_dirs) {
-        return Ok(());
-    }
-    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            if is_excluded(&path, exclude_dirs) {
-                continue;
-            }
-            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext = path
-            .extension()
-            .and_then(|v| v.to_str())
-            .unwrap_or("")
-            .to_lowercase();
-        let file = normalize_source_path(&path);
-        let allowed = (lang == "c" && ext == "c")
-            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
-                && (ext == "cpp" || ext == "cxx" || ext == "cc"))
-            || (lang == "asm" && (ext == "s" || ext == "asm"));
-        if allowed {
-            out.push(file);
-        }
-    }
-    Ok(())
-}
-
-fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
-    exclude_dirs.iter().any(|dir| path.starts_with(dir))
-}
-
-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()
 }
 
 fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String> {
@@ -235,11 +172,11 @@ fn build_objects(
 ) -> Result<Vec<String>, String> {
     let mut objects = Vec::new();
     for source in sources {
-        let obj_path = object_path(obj_dir, source, obj_ext);
+        let obj_path = common::object_path(obj_dir, source, obj_ext);
         if let Some(parent) = Path::new(&obj_path).parent() {
             fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
         }
-        if needs_rebuild(source, &obj_path) {
+        if common::needs_rebuild(source, &obj_path) {
             let mut cmd = Command::new(compiler);
             cmd.arg("/nologo");
             match ctx.language.to_lowercase().as_str() {
@@ -270,34 +207,50 @@ fn build_objects(
                 cmd.arg(format!("/I{dir}"));
             }
             cmd.arg("/c").arg(source).arg(format!("/Fo:{}", obj_path));
-            match cmd.status() {
-                Ok(status) if status.success() => {}
-                Ok(_) => return Err("Build failed".to_string()),
-                Err(err) => return Err(format!("Build failed: {err}")),
+            cmd.arg("/showIncludes");
+
+            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');
+                }
             }
+            
+            if !output.status.success() {
+                eprint!("{}", clean_stdout);
+                eprint!("{}", stderr);
+                return Err("Build failed".to_string());
+            } else {
+                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));
+            }
+            std::fs::write(&d_path, d_content).map_err(|err| format!("d file error: {err}"))?;
         }
         objects.push(obj_path);
     }
     Ok(objects)
 }
-
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
-    let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
-    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
-    out.to_string_lossy().to_string()
-}
-
-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());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
-    }
-}

src/core/builder/nasm.rs

@@ -1,7 +1,8 @@
 use crate::core::builder::BuildContext;
+use crate::core::builder::common;
 use crate::platform;
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::process::Command;
 use std::time::Instant;
 
@@ -15,7 +16,7 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
+    let sources = collect_sources(ctx)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(assembler, &sources, &obj_dir, ctx, "o")?;
 
@@ -82,76 +83,9 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-pub(crate) fn collect_sources(
-    language: &str,
-    exclude_dirs: &[PathBuf],
-) -> Result<Vec<String>, String> {
-    let lang = language.to_lowercase();
-    let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
-    sources.sort();
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
-    }
-    Ok(sources)
-}
-
-fn collect_sources_rec(
-    dir: &str,
-    lang: &str,
-    out: &mut Vec<String>,
-    exclude_dirs: &[PathBuf],
-) -> Result<(), String> {
-    let dir_path = Path::new(dir);
-    let full_dir = if dir_path.is_absolute() {
-        dir_path.to_path_buf()
-    } else {
-        std::env::current_dir()
-            .map_err(|err| format!("src dir error: {err}"))?
-            .join(dir_path)
-    };
-    if is_excluded(&full_dir, exclude_dirs) {
-        return Ok(());
-    }
-    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            if is_excluded(&path, exclude_dirs) {
-                continue;
-            }
-            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext_raw = path.extension().and_then(|v| v.to_str()).unwrap_or("");
-        let ext = ext_raw.to_lowercase();
-        let file = normalize_source_path(&path);
-        let allowed = lang == "asm" && (ext == "asm" || (ext == "s" && ext_raw == "s"));
-        if allowed {
-            out.push(file);
-        }
-    }
-    Ok(())
-}
-
-fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
-    exclude_dirs.iter().any(|dir| path.starts_with(dir))
-}
-
-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(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    // NASM handles lowercase .s and .asm only (not .S which is GCC preprocessed)
+    common::collect_sources(&["asm", "s"], ctx.exclude_dirs)
 }
 
 fn build_objects(
@@ -164,11 +98,11 @@ fn build_objects(
     let mut objects = Vec::new();
     let format = nasm_format(ctx.platform);
     for source in sources {
-        let obj_path = object_path(obj_dir, source, obj_ext);
+        let obj_path = common::object_path(obj_dir, source, obj_ext);
         if let Some(parent) = Path::new(&obj_path).parent() {
             fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
         }
-        if needs_rebuild(source, &obj_path) {
+        if common::needs_rebuild(source, &obj_path) {
             let mut cmd = Command::new(assembler);
             cmd.arg("-f")
                 .arg(format)
@@ -224,24 +158,3 @@ fn nasm_format(platform: Option<&str>) -> &'static str {
         "elf64"
     }
 }
-
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
-    let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
-    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
-    out.to_string_lossy().to_string()
-}
-
-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());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
-    }
-}

src/core/builder/unix_cc.rs

@@ -1,7 +1,8 @@
 use crate::core::builder::BuildContext;
+use crate::core::builder::common;
 use crate::platform;
 use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::process::Command;
 use std::time::Instant;
 
@@ -12,7 +13,8 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
         ctx.compiler
     };
     let start_time = Instant::now();
-    let sources = collect_sources(ctx.language, ctx.exclude_dirs)?;
+    let extensions = source_extensions(ctx.language);
+    let sources = common::collect_sources(&extensions, ctx.exclude_dirs)?;
     let obj_dir = Path::new("./target").join(ctx.profile).join("obj");
     let objects = build_objects(compiler, &sources, &obj_dir, ctx, "o")?;
 
@@ -44,12 +46,6 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     for obj in &objects {
         cmd.arg(obj);
     }
-    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!("-L{dir}"));
     }
@@ -76,82 +72,19 @@ pub fn build(ctx: &BuildContext) -> Result<f64, String> {
     }
 }
 
-pub(crate) fn collect_sources(
-    language: &str,
-    exclude_dirs: &[PathBuf],
-) -> Result<Vec<String>, String> {
+pub(crate) fn collect_sources(ctx: &BuildContext) -> Result<Vec<String>, String> {
+    let extensions = source_extensions(ctx.language);
+    common::collect_sources(&extensions, ctx.exclude_dirs)
+}
+
+fn source_extensions(language: &str) -> Vec<&str> {
     let lang = language.to_lowercase();
-    let mut sources = Vec::new();
-    collect_sources_rec("./src", &lang, &mut sources, exclude_dirs)?;
-    sources.sort();
-    if sources.is_empty() {
-        return Err("No source files found in ./src".to_string());
+    match lang.as_str() {
+        "c" => vec!["c"],
+        "c++" | "cpp" | "cxx" => vec!["cpp", "cxx", "cc"],
+        "asm" => vec!["s", "S", "asm"],
+        _ => vec!["c"],
     }
-    Ok(sources)
-}
-
-fn collect_sources_rec(
-    dir: &str,
-    lang: &str,
-    out: &mut Vec<String>,
-    exclude_dirs: &[PathBuf],
-) -> Result<(), String> {
-    let dir_path = Path::new(dir);
-    let full_dir = if dir_path.is_absolute() {
-        dir_path.to_path_buf()
-    } else {
-        std::env::current_dir()
-            .map_err(|err| format!("src dir error: {err}"))?
-            .join(dir_path)
-    };
-    if is_excluded(&full_dir, exclude_dirs) {
-        return Ok(());
-    }
-    let entries = fs::read_dir(&full_dir).map_err(|err| format!("src dir error: {err}"))?;
-    for entry in entries {
-        let entry = entry.map_err(|err| format!("src dir error: {err}"))?;
-        let path = entry.path();
-        if path.is_dir() {
-            if is_excluded(&path, exclude_dirs) {
-                continue;
-            }
-            collect_sources_rec(&path.to_string_lossy(), lang, out, exclude_dirs)?;
-            continue;
-        }
-        if !path.is_file() {
-            continue;
-        }
-        let ext = path
-            .extension()
-            .and_then(|v| v.to_str())
-            .unwrap_or("")
-            .to_lowercase();
-        let file = normalize_source_path(&path);
-        let allowed = (lang == "c" && ext == "c")
-            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
-                && (ext == "cpp" || ext == "cxx" || ext == "cc"))
-            || (lang == "asm" && (ext == "s" || ext == "asm"));
-        if allowed {
-            out.push(file);
-        }
-    }
-    Ok(())
-}
-
-fn is_excluded(path: &Path, exclude_dirs: &[PathBuf]) -> bool {
-    exclude_dirs.iter().any(|dir| path.starts_with(dir))
-}
-
-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()
 }
 
 fn default_flags(profile: &str) -> &'static [&'static str] {
@@ -178,11 +111,11 @@ fn build_objects(
 ) -> Result<Vec<String>, String> {
     let mut objects = Vec::new();
     for source in sources {
-        let obj_path = object_path(obj_dir, source, obj_ext);
+        let obj_path = common::object_path(obj_dir, source, obj_ext);
         if let Some(parent) = Path::new(&obj_path).parent() {
             fs::create_dir_all(parent).map_err(|err| format!("obj dir error: {err}"))?;
         }
-        if needs_rebuild(source, &obj_path) {
+        if common::needs_rebuild(source, &obj_path) {
             let mut cmd = Command::new(compiler);
             cmd.arg("-c").arg(source).arg("-o").arg(&obj_path);
             if ctx.kind == "sharedlib" {
@@ -208,6 +141,8 @@ fn build_objects(
             for dir in ctx.include_dirs {
                 cmd.arg(format!("-I{dir}"));
             }
+            let d_path = Path::new(&obj_path).with_extension("d");
+            cmd.arg("-MMD").arg("-MF").arg(&d_path);
             match cmd.status() {
                 Ok(status) if status.success() => {}
                 Ok(_) => return Err("Build failed".to_string()),
@@ -227,24 +162,3 @@ fn asm_lang_flag(source: &str) -> Option<&'static str> {
         _ => None,
     }
 }
-
-fn object_path(obj_dir: &Path, source: &str, obj_ext: &str) -> String {
-    let src_path = Path::new(source);
-    let rel = src_path
-        .strip_prefix("./src")
-        .or_else(|_| src_path.strip_prefix("src"))
-        .unwrap_or(src_path);
-    let mut out = obj_dir.join(rel);
-    out.set_extension(obj_ext.trim_start_matches('.'));
-    out.to_string_lossy().to_string()
-}
-
-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());
-    match (src_time, obj_time) {
-        (Ok(s), Ok(o)) => s > o,
-        (Ok(_), Err(_)) => true,
-        _ => true,
-    }
-}