use anyhow::{Context, Result};
use std::collections::HashMap;
use std::fs;
use std::path::Path;
use std::process::Command;
use parking_lot::Mutex;
use crate::processors::{check_command_output, run_command_capture};
static SHELL_COMMAND_CACHE: Mutex<Option<HashMap<String, Vec<String>>>> = Mutex::new(None);
fn cached_shell_command(cmd_line: &str, runner: impl FnOnce(&str) -> Result<Vec<String>>) -> Result<Vec<String>> {
let mut guard = SHELL_COMMAND_CACHE.lock();
let cache = guard.get_or_insert_with(HashMap::new);
if let Some(cached) = cache.get(cmd_line) {
return Ok(cached.clone());
}
let result = runner(cmd_line)?;
cache.insert(cmd_line.to_string(), result.clone());
Ok(result)
}
#[derive(Default)]
pub(super) struct SourceFlags {
pub(super) compile_args_before: Vec<String>,
pub(super) compile_args_after: Vec<String>,
pub(super) link_args_before: Vec<String>,
pub(super) link_args_after: Vec<String>,
}
fn extract_comment_value(line: &str) -> Option<&str> {
let trimmed = line.trim();
if let Some(rest) = trimmed.strip_prefix("//") {
return Some(rest.trim());
}
if let Some(rest) = trimmed.strip_prefix("/*") {
return rest.strip_suffix("*/").map(|s| s.trim());
}
if let Some(rest) = trimmed.strip_prefix('*') {
let rest = rest.trim();
if rest.is_empty() || rest == "/" {
return None;
}
return Some(rest.strip_suffix("*/").map(|s| s.trim()).unwrap_or(rest));
}
None
}
pub(super) fn should_exclude_for_profile(source: &Path, profile_name: &str) -> bool {
if profile_name.is_empty() {
return false;
}
let content = match fs::read_to_string(source) {
Ok(c) => c,
Err(_) => return false,
};
for line in content.lines() {
let Some(value_part) = extract_comment_value(line) else {
continue;
};
if let Some(rest) = value_part.strip_prefix("EXCLUDE_PROFILE")
&& let Some(profiles_str) = rest.strip_prefix('=') {
let excluded_profiles: Vec<&str> = profiles_str.split_whitespace().collect();
if excluded_profiles.contains(&profile_name) {
return true;
}
}
}
false
}
pub(super) fn parse_source_flags(source: &Path, profile_name: &str) -> Result<SourceFlags> {
let content = fs::read_to_string(source)
.with_context(|| format!("Failed to read source file: {}", source.display()))?;
let mut flags = SourceFlags::default();
let args_var_names = [
"EXTRA_COMPILE_FLAGS_BEFORE",
"EXTRA_COMPILE_FLAGS_AFTER",
"EXTRA_LINK_FLAGS_BEFORE",
"EXTRA_LINK_FLAGS_AFTER",
];
let cmd_var_names = [
"EXTRA_COMPILE_CMD",
"EXTRA_LINK_CMD",
];
let shell_var_names = [
"EXTRA_COMPILE_SHELL",
"EXTRA_LINK_SHELL",
];
for line in content.lines() {
let Some(value_part) = extract_comment_value(line) else {
continue;
};
for var_name in &args_var_names {
if let Some((rest, applies)) = match_directive_with_profile(value_part, var_name, profile_name)
&& applies
&& let Some(raw_value) = rest.strip_prefix('=') {
let expanded = expand_backticks(raw_value.trim())?;
let args: Vec<String> = expanded
.split_whitespace()
.map(String::from)
.collect();
match *var_name {
"EXTRA_COMPILE_FLAGS_BEFORE" => flags.compile_args_before.extend(args),
"EXTRA_COMPILE_FLAGS_AFTER" => flags.compile_args_after.extend(args),
"EXTRA_LINK_FLAGS_BEFORE" => flags.link_args_before.extend(args),
"EXTRA_LINK_FLAGS_AFTER" => flags.link_args_after.extend(args),
_ => {}
}
}
}
for var_name in &cmd_var_names {
if let Some((rest, applies)) = match_directive_with_profile(value_part, var_name, profile_name)
&& applies
&& let Some(raw_value) = rest.strip_prefix('=') {
let cmd = raw_value.trim();
let args = cached_shell_command(cmd, run_command_for_flags)?;
match *var_name {
"EXTRA_COMPILE_CMD" => flags.compile_args_after.extend(args),
"EXTRA_LINK_CMD" => flags.link_args_after.extend(args),
_ => {}
}
}
}
for var_name in &shell_var_names {
if let Some((rest, applies)) = match_directive_with_profile(value_part, var_name, profile_name)
&& applies
&& let Some(raw_value) = rest.strip_prefix('=') {
let cmd = raw_value.trim();
let args = cached_shell_command(cmd, run_shell_for_flags)?;
match *var_name {
"EXTRA_COMPILE_SHELL" => flags.compile_args_after.extend(args),
"EXTRA_LINK_SHELL" => flags.link_args_after.extend(args),
_ => {}
}
}
}
}
Ok(flags)
}
fn match_directive_with_profile<'a>(line: &'a str, directive: &str, profile_name: &str) -> Option<(&'a str, bool)> {
if let Some(rest) = line.strip_prefix(directive) {
if let Some(rest_after_bracket) = rest.strip_prefix('[') {
if let Some(bracket_end) = rest_after_bracket.find(']') {
let specified_profile = &rest_after_bracket[..bracket_end];
let rest_after_suffix = &rest_after_bracket[bracket_end + 1..];
let applies = specified_profile == profile_name;
return Some((rest_after_suffix, applies));
}
None
} else {
Some((rest, true))
}
} else {
None
}
}
fn run_command_for_flags(cmd_line: &str) -> Result<Vec<String>> {
let parts: Vec<&str> = cmd_line.split_whitespace().collect();
if parts.is_empty() {
return Ok(Vec::new());
}
let program = parts[0];
let args = &parts[1..];
let mut cmd = Command::new(program);
cmd.args(args);
let _guard = crate::processors::suspend_tool_check();
let output = run_command_capture(&mut cmd)?;
check_command_output(&output, cmd_line)?;
let stdout = String::from_utf8_lossy(&output.stdout).trim().to_owned();
Ok(stdout.split_whitespace().map(String::from).collect())
}
fn run_shell_for_flags(cmd_line: &str) -> Result<Vec<String>> {
if cmd_line.is_empty() {
return Ok(Vec::new());
}
let mut cmd = Command::new("sh");
cmd.arg("-c").arg(cmd_line);
let _guard = crate::processors::suspend_tool_check();
let output = run_command_capture(&mut cmd)?;
check_command_output(&output, cmd_line)?;
let stdout = String::from_utf8_lossy(&output.stdout).trim().to_owned();
Ok(stdout.split_whitespace().map(String::from).collect())
}
fn run_backtick_command(cmd_str: &str) -> Result<Vec<String>> {
let mut cmd = Command::new("sh");
cmd.arg("-c").arg(cmd_str);
let _guard = crate::processors::suspend_tool_check();
let output = run_command_capture(&mut cmd)?;
check_command_output(&output, cmd_str)?;
let stdout = String::from_utf8_lossy(&output.stdout).trim().to_owned();
Ok(vec![stdout])
}
fn expand_backticks(value: &str) -> Result<String> {
if !value.contains('`') {
return Ok(value.to_string());
}
let mut result = String::new();
let mut rest = value;
while let Some(start) = rest.find('`') {
result.push_str(&rest[..start]);
let after_start = &rest[start + 1..];
let end = after_start.find('`').ok_or_else(|| {
anyhow::anyhow!("Unmatched backtick in value: {}", value)
})?;
let cmd_str = &after_start[..end];
let cached = cached_shell_command(cmd_str, run_backtick_command)?;
let stdout = cached.first().map(|s| s.as_str()).unwrap_or("");
result.push_str(stdout);
rest = &after_start[end + 1..];
}
result.push_str(rest);
Ok(result)
}