Added:

- Modular builders for `gcc`, `clang`, `msvc`
- Platform-specific binary path generation (Linux/macOS/Windows)

Changed:
- Build configuration moved to `[build]` (`language`, `standard`, `compiler`)
- `dcr.toml` formatting now includes the `[build]` section
- Build uses built-in `debug/release` flags per compiler
- Build compiles all `*.c/*.cpp` files in `src/` into a single binary (no incremental build)
- Updated `dcr.toml` examples in documentation

src/core/builder/clang.rs

@@ -0,0 +1,81 @@
+use crate::core::builder::BuildContext;
+use crate::platform;
+use std::fs;
+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 mut cmd = Command::new(compiler);
+    let sources = collect_sources(ctx.language)?;
+    for source in &sources {
+        cmd.arg(source);
+    }
+    if !ctx.standard.is_empty() {
+        cmd.arg(format!("-std={}", ctx.standard));
+    }
+    for flag in default_flags(ctx.profile) {
+        cmd.arg(flag);
+    }
+    cmd.arg("-o")
+        .arg(platform::bin_path(ctx.profile, ctx.project_name));
+
+    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}")),
+    }
+}
+
+fn collect_sources(language: &str) -> Result<Vec<String>, String> {
+    let lang = language.to_lowercase();
+    let mut sources = Vec::new();
+    let entries = fs::read_dir("./src").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_file() {
+            continue;
+        }
+        let ext = path
+            .extension()
+            .and_then(|v| v.to_str())
+            .unwrap_or("")
+            .to_lowercase();
+        let file = path.to_string_lossy().to_string();
+        let allowed = (lang == "c" && ext == "c")
+            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
+                && (ext == "cpp" || ext == "cxx" || ext == "cc"));
+        if allowed {
+            sources.push(file);
+        }
+    }
+    sources.sort();
+    if sources.is_empty() {
+        return Err("No source files found in ./src".to_string());
+    }
+    Ok(sources)
+}
+
+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",
+        ],
+        _ => &[],
+    }
+}

src/core/builder/gcc.rs

@@ -0,0 +1,81 @@
+use crate::core::builder::BuildContext;
+use crate::platform;
+use std::fs;
+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 mut cmd = Command::new(compiler);
+    let sources = collect_sources(ctx.language)?;
+    for source in &sources {
+        cmd.arg(source);
+    }
+    if !ctx.standard.is_empty() {
+        cmd.arg(format!("-std={}", ctx.standard));
+    }
+    for flag in default_flags(ctx.profile) {
+        cmd.arg(flag);
+    }
+    cmd.arg("-o")
+        .arg(platform::bin_path(ctx.profile, ctx.project_name));
+
+    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}")),
+    }
+}
+
+fn collect_sources(language: &str) -> Result<Vec<String>, String> {
+    let lang = language.to_lowercase();
+    let mut sources = Vec::new();
+    let entries = fs::read_dir("./src").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_file() {
+            continue;
+        }
+        let ext = path
+            .extension()
+            .and_then(|v| v.to_str())
+            .unwrap_or("")
+            .to_lowercase();
+        let file = path.to_string_lossy().to_string();
+        let allowed = (lang == "c" && ext == "c")
+            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
+                && (ext == "cpp" || ext == "cxx" || ext == "cc"));
+        if allowed {
+            sources.push(file);
+        }
+    }
+    sources.sort();
+    if sources.is_empty() {
+        return Err("No source files found in ./src".to_string());
+    }
+    Ok(sources)
+}
+
+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",
+        ],
+        _ => &[],
+    }
+}

src/core/builder/mod.rs

@@ -0,0 +1,28 @@
+pub mod clang;
+pub mod gcc;
+pub mod msvc;
+
+pub struct BuildContext<'a> {
+    pub profile: &'a str,
+    pub project_name: &'a str,
+    pub compiler: &'a str,
+    pub language: &'a str,
+    pub standard: &'a str,
+}
+
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    let compiler = ctx.compiler.to_lowercase();
+    if compiler.contains("clang-cl") {
+        return msvc::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)
+}

src/core/builder/msvc.rs

@@ -0,0 +1,116 @@
+use crate::core::builder::BuildContext;
+use crate::platform;
+use std::fs;
+use std::process::Command;
+use std::time::Instant;
+
+pub fn build(ctx: &BuildContext) -> Result<f64, String> {
+    let compiler = if ctx.compiler.is_empty() {
+        "cl"
+    } else {
+        ctx.compiler
+    };
+    let start_time = Instant::now();
+    let mut cmd = Command::new(compiler);
+    let sources = collect_sources(ctx.language)?;
+
+    cmd.arg("/nologo");
+    match ctx.language.to_lowercase().as_str() {
+        "c" => {
+            cmd.arg("/TC");
+        }
+        "c++" | "cpp" | "cxx" => {
+            cmd.arg("/TP");
+        }
+        _ => {
+            return Err("Unsupported language".to_string());
+        }
+    }
+
+    if !ctx.standard.is_empty() {
+        let std_flag = msvc_standard_flag(ctx.language, ctx.standard)?;
+        cmd.arg(std_flag);
+    }
+
+    for flag in default_flags(ctx.profile) {
+        cmd.arg(flag);
+    }
+
+    for source in &sources {
+        cmd.arg(source);
+    }
+    cmd.arg(format!(
+        "/Fe:{}",
+        platform::bin_path(ctx.profile, ctx.project_name)
+    ));
+
+    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}")),
+    }
+}
+
+fn collect_sources(language: &str) -> Result<Vec<String>, String> {
+    let lang = language.to_lowercase();
+    let mut sources = Vec::new();
+    let entries = fs::read_dir("./src").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_file() {
+            continue;
+        }
+        let ext = path
+            .extension()
+            .and_then(|v| v.to_str())
+            .unwrap_or("")
+            .to_lowercase();
+        let file = path.to_string_lossy().to_string();
+        let allowed = (lang == "c" && ext == "c")
+            || ((lang == "c++" || lang == "cpp" || lang == "cxx")
+                && (ext == "cpp" || ext == "cxx" || ext == "cc"));
+        if allowed {
+            sources.push(file);
+        }
+    }
+    sources.sort();
+    if sources.is_empty() {
+        return Err("No source files found in ./src".to_string());
+    }
+    Ok(sources)
+}
+
+fn msvc_standard_flag(language: &str, standard: &str) -> Result<String, String> {
+    let lang = language.to_lowercase();
+    let std = standard.to_lowercase();
+    if lang == "c" {
+        return match std.as_str() {
+            "c11" => Ok("/std:c11".to_string()),
+            "c17" => Ok("/std:c17".to_string()),
+            _ => Err("Unsupported C standard for MSVC".to_string()),
+        };
+    }
+    if lang == "c++" || lang == "cpp" || lang == "cxx" {
+        return match std.as_str() {
+            "c++11" => Ok("/std:c++11".to_string()),
+            "c++14" => Ok("/std:c++14".to_string()),
+            "c++17" => Ok("/std:c++17".to_string()),
+            "c++20" => Ok("/std:c++20".to_string()),
+            "c++23" => Ok("/std:c++latest".to_string()),
+            _ => Err("Unsupported C++ standard for MSVC".to_string()),
+        };
+    }
+    Err("Unsupported language".to_string())
+}
+
+fn default_flags(profile: &str) -> &'static [&'static str] {
+    match profile {
+        "release" => &["/O2", "/DNDEBUG"],
+        "debug" => &["/Od", "/Zi", "/W4", "/DDEBUG", "/Oy-"],
+        _ => &[],
+    }
+}

src/core/config.rs

@@ -5,6 +5,7 @@ use toml::map::Map;
 
 const DEFAULT_VERSION: &str = "0.1.0";
 const DEFAULT_LANGUAGE: &str = "c";
+const DEFAULT_STANDARD: &str = "c11";
 const DEFAULT_COMPILER: &str = "clang";
 
 #[derive(Debug)]
@@ -101,12 +102,24 @@ impl Config {
             .and_then(|v| v.as_table())
             .ok_or_else(|| ConfigError::Invalid("missing [package]".into()))?;
 
-        for key in ["name", "version", "language", "compiler"] {
+        for key in ["name", "version"] {
             let value = package.get(key).and_then(|v| v.as_str()).unwrap_or("");
             if value.trim().is_empty() {
                 return Err(ConfigError::Invalid(format!("package.{key} is empty")));
             }
         }
+
+        let build = self
+            .get("build")
+            .and_then(|v| v.as_table())
+            .ok_or_else(|| ConfigError::Invalid("missing [build]".into()))?;
+
+        for key in ["language", "standard", "compiler"] {
+            let value = build.get(key).and_then(|v| v.as_str()).unwrap_or("");
+            if value.trim().is_empty() {
+                return Err(ConfigError::Invalid(format!("build.{key} is empty")));
+            }
+        }
         Ok(())
     }
 
@@ -128,7 +141,7 @@ fn read_toml(path: &Path) -> Result<Value, ConfigError> {
 }
 
 fn write_toml(path: &Path, value: &Value) -> Result<(), ConfigError> {
-    let content = toml::to_string(value)?;
+    let content = format_toml(value)?;
     fs::write(path, content)?;
     Ok(())
 }
@@ -145,22 +158,78 @@ fn default_toml() -> Result<Value, ConfigError> {
         "version".to_string(),
         Value::String(DEFAULT_VERSION.to_string()),
     );
-    package.insert(
+    let mut build = Map::new();
+    build.insert(
         "language".to_string(),
         Value::String(DEFAULT_LANGUAGE.to_string()),
     );
-    package.insert(
+    build.insert(
+        "standard".to_string(),
+        Value::String(DEFAULT_STANDARD.to_string()),
+    );
+    build.insert(
         "compiler".to_string(),
         Value::String(DEFAULT_COMPILER.to_string()),
     );
 
     let mut root = Map::new();
     root.insert("package".to_string(), Value::Table(package));
+    root.insert("build".to_string(), Value::Table(build));
     root.insert("dependencies".to_string(), Value::Table(Map::new()));
 
     Ok(Value::Table(root))
 }
 
+fn format_toml(value: &Value) -> Result<String, ConfigError> {
+    let root = value
+        .as_table()
+        .ok_or_else(|| ConfigError::Invalid("root is not a table".into()))?;
+
+    let package = root
+        .get("package")
+        .and_then(|v| v.as_table())
+        .ok_or_else(|| ConfigError::Invalid("missing [package]".into()))?;
+    let build = root
+        .get("build")
+        .and_then(|v| v.as_table())
+        .ok_or_else(|| ConfigError::Invalid("missing [build]".into()))?;
+    let deps = root
+        .get("dependencies")
+        .and_then(|v| v.as_table())
+        .ok_or_else(|| ConfigError::Invalid("missing [dependencies]".into()))?;
+
+    let name = package.get("name").and_then(|v| v.as_str()).unwrap_or("");
+    let version = package
+        .get("version")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+
+    let language = build.get("language").and_then(|v| v.as_str()).unwrap_or("");
+    let standard = build.get("standard").and_then(|v| v.as_str()).unwrap_or("");
+    let compiler = build.get("compiler").and_then(|v| v.as_str()).unwrap_or("");
+
+    let mut out = String::new();
+    out.push_str("[package]\n");
+    out.push_str(&format!("name = \"{name}\"\n"));
+    out.push_str(&format!("version = \"{version}\"\n\n"));
+
+    out.push_str("[build]\n");
+    out.push_str(&format!("language = \"{language}\"\n"));
+    out.push_str(&format!("standard = \"{standard}\"\n"));
+    out.push_str(&format!("compiler = \"{compiler}\"\n\n"));
+
+    out.push_str("[dependencies]\n");
+    if !deps.is_empty() {
+        let mut keys: Vec<&String> = deps.keys().collect();
+        keys.sort();
+        for key in keys {
+            let val = deps.get(key).and_then(|v| v.as_str()).unwrap_or("");
+            out.push_str(&format!("{key} = \"{val}\"\n"));
+        }
+    }
+    Ok(out)
+}
+
 fn get_path<'a>(value: &'a Value, path: &[&str]) -> Option<&'a Value> {
     let mut current = value;
     for key in path {

src/core/mod.rs

@@ -1 +1,2 @@
+pub mod builder;
 pub mod config;