136 lines
3.7 KiB
Rust
136 lines
3.7 KiB
Rust
use std::{
|
|
collections::{HashMap, HashSet},
|
|
fs, io,
|
|
path::{Path, PathBuf},
|
|
};
|
|
|
|
use mon::{Parser, ParserIter, ascii_whitespace1, input::InputIter};
|
|
|
|
use crate::{
|
|
Parseable,
|
|
repo::profile::{LineBasedFileExpr, Profile},
|
|
};
|
|
|
|
mod parsers;
|
|
|
|
#[derive(Debug, thiserror::Error)]
|
|
pub enum Error {
|
|
#[error("{0}: io error: {1}")]
|
|
Io(PathBuf, io::Error),
|
|
#[error("parser error: {0}")]
|
|
Parser(String),
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
|
struct Key(String);
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct Literal(String);
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct Interpolation(String);
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum Segment {
|
|
Literal(Literal),
|
|
Interpolation(Interpolation),
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct Assignment(Key, Vec<Segment>);
|
|
|
|
pub(super) fn evaluate<P: AsRef<Path>>(
|
|
parents: &[Profile],
|
|
path: P,
|
|
) -> Result<HashMap<String, String>, Error> {
|
|
let parsed = match fs::read_to_string(path.as_ref().join("make.defaults")) {
|
|
Ok(contents) => parse(&contents)?,
|
|
Err(e) if matches!(e.kind(), io::ErrorKind::NotFound) => HashMap::new(),
|
|
Err(e) => return Err(Error::Io(path.as_ref().to_path_buf(), e)),
|
|
};
|
|
|
|
let mut vars = interpolate(parents, parsed);
|
|
|
|
incremental(parents, &mut vars);
|
|
|
|
Ok(vars)
|
|
}
|
|
|
|
fn incremental(parents: &[Profile], vars: &mut HashMap<String, String>) {
|
|
for key in [
|
|
"USE",
|
|
"USE_EXPAND",
|
|
"USE_EXPAND_HIDDEN",
|
|
"CONFIG_PROTECT",
|
|
"CONFIG_PROTECT_MASK",
|
|
] {
|
|
let mut accumulated = Vec::new();
|
|
|
|
for parent in parents {
|
|
if let Some(values) = parent.make_defaults().get(key) {
|
|
accumulated.extend(values.split_ascii_whitespace());
|
|
}
|
|
}
|
|
|
|
if let Some(values) = vars.get(key) {
|
|
accumulated.extend(values.split_ascii_whitespace());
|
|
}
|
|
|
|
let mut final_values = Vec::new();
|
|
|
|
for var in accumulated {
|
|
if var == "-*" {
|
|
final_values.clear();
|
|
} else if let Some(stripped) = var.strip_prefix("-") {
|
|
final_values.retain(|v| *v != stripped);
|
|
} else {
|
|
final_values.push(var);
|
|
}
|
|
}
|
|
|
|
let mut seen = HashSet::new();
|
|
final_values.retain(|v| seen.insert(*v));
|
|
|
|
if !final_values.is_empty() {
|
|
vars.insert(key.to_string(), final_values.join(" "));
|
|
}
|
|
}
|
|
}
|
|
|
|
fn interpolate(parents: &[Profile], vars: HashMap<Key, Vec<Segment>>) -> HashMap<String, String> {
|
|
let parent_vars = parents
|
|
.iter()
|
|
.flat_map(|parent| parent.make_defaults().clone().into_iter())
|
|
.collect::<HashMap<_, _>>();
|
|
|
|
vars.into_iter()
|
|
.map(|(key, segments)| {
|
|
let interpolated = segments
|
|
.into_iter()
|
|
.map(|segment| match segment {
|
|
Segment::Interpolation(i) => parent_vars.get(&i.0).cloned().unwrap_or_default(),
|
|
Segment::Literal(literal) => literal.0.trim().to_string(),
|
|
})
|
|
.collect::<Vec<_>>();
|
|
|
|
let joined = interpolated.join("");
|
|
|
|
(key.0, joined)
|
|
})
|
|
.collect::<HashMap<String, String>>()
|
|
}
|
|
|
|
fn parse(contents: &str) -> Result<HashMap<Key, Vec<Segment>>, Error> {
|
|
Ok(LineBasedFileExpr::<Assignment>::parser()
|
|
.separated_by_with_opt_trailing(ascii_whitespace1())
|
|
.many()
|
|
.parse_finished(InputIter::new(contents))
|
|
.map_err(|e| Error::Parser(dbg!(e).rest().to_string()))?
|
|
.into_iter()
|
|
.filter_map(|expr| match expr {
|
|
LineBasedFileExpr::Comment => None,
|
|
LineBasedFileExpr::Expr(Assignment(key, value)) => Some((key, value)),
|
|
})
|
|
.collect())
|
|
}
|