use std::sync::Arc;
use crate::cache::summary::MacroFact;
use crate::cache::summary::MacroKind;
use crate::preprocess::condition::{Lookup, MacroValues};
use cpp_parser::SourceRange;
mod compose;
#[cfg(test)]
mod differential;
mod skeleton;
#[cfg(test)]
mod tests;
mod unit;
pub use compose::{Composed, compose};
pub use skeleton::{Skeleton, Step};
pub use unit::{ComposedFile, UnitComposition, compose_unit};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct EnvId(u64);
impl EnvId {
pub const EMPTY: EnvId = EnvId(0x9e37_79b9_7f4a_7c15);
pub fn number(self) -> u64 {
self.0
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Definition {
name: Arc<str>,
function_like: bool,
body: Option<Arc<str>>,
evaluable: Option<Box<crate::macros::MacroDef>>,
alias: Option<Arc<str>>,
hash: u64,
}
impl Definition {
pub fn of(fact: &MacroFact, text: &str) -> Option<Self> {
if fact.kind != MacroKind::Definition {
return None;
}
let body = match fact.body_range {
Some(range) => Some(Arc::from(slice(text, range)?.trim())),
None => None,
};
let hash = hash_definition(fact.name.as_str(), fact.function_like, body.as_deref());
let evaluable = build_macro_def(fact, text, body.as_deref()).map(Box::new);
Some(Self {
name: Arc::from(fact.name.as_str()),
function_like: fact.function_like,
body,
evaluable,
alias: fact.alias.as_deref().map(Arc::from),
hash,
})
}
pub fn new(name: &str, function_like: bool, body: Option<Arc<str>>) -> Self {
let hash = hash_definition(name, function_like, body.as_deref());
Definition {
name: Arc::from(name),
function_like,
body,
evaluable: None,
alias: None,
hash,
}
}
pub fn name(&self) -> &str {
&self.name
}
pub fn is_function_like(&self) -> bool {
self.function_like
}
pub fn body(&self) -> Option<&str> {
self.body.as_deref()
}
pub fn hash(&self) -> u64 {
self.hash
}
pub(crate) fn evaluable(&self) -> Option<&crate::macros::MacroDef> {
self.evaluable.as_deref()
}
pub(crate) fn alias(&self) -> Option<&str> {
self.alias.as_deref()
}
}
fn slice(text: &str, range: SourceRange) -> Option<&str> {
let start = range.start_offset;
let end = start.checked_add(range.length)?;
if end > text.len() || !text.is_char_boundary(start) || !text.is_char_boundary(end) {
return None;
}
Some(&text[start..end])
}
fn hash_definition(name: &str, function_like: bool, body: Option<&str>) -> u64 {
let mut bytes = Vec::with_capacity(name.len() + body.map_or(0, str::len) + 3);
bytes.extend_from_slice(name.as_bytes());
bytes.push(0);
match body {
Some(body) => {
bytes.push(1);
bytes.extend_from_slice(body.as_bytes());
}
None => bytes.push(2),
}
bytes.push(u8::from(function_like));
crate::cache::fnv1a64(&bytes)
}
#[derive(Debug, Clone)]
pub struct Env {
frame: Option<Arc<Frame>>,
id: EnvId,
}
#[derive(Debug)]
struct Frame {
parent: Option<Arc<Frame>>,
changes: Vec<Change>,
}
#[derive(Debug, Clone)]
struct Change {
name: Arc<str>,
definition: Option<Arc<Definition>>,
hash: u64,
}
impl Env {
pub fn empty() -> Self {
Env {
frame: None,
id: EnvId::EMPTY,
}
}
pub fn id(&self) -> EnvId {
self.id
}
pub fn define(&self, definition: Arc<Definition>) -> Self {
self.with(Change::define(definition))
}
pub fn undef(&self, name: &str) -> Self {
self.with(Change::undef(name))
}
fn with(&self, change: Change) -> Self {
Self::with_changes(self, vec![change])
}
pub fn apply(
&self,
changes: impl IntoIterator<Item = (Arc<str>, Option<Arc<Definition>>)>,
) -> Self {
let mut changes: Vec<Change> = changes
.into_iter()
.map(|(name, definition)| Change::new(name, definition))
.collect();
changes.reverse();
let mut seen = std::collections::HashSet::new();
changes.retain(|change| seen.insert(change.name.clone()));
changes.reverse();
Self::with_changes(self, changes)
}
fn with_changes(&self, changes: Vec<Change>) -> Self {
if changes.is_empty() {
return self.clone();
}
let mut hashes: Vec<(u64, u64)> = changes
.iter()
.map(|change| (hash_name(&change.name), change.hash))
.collect();
hashes.sort_unstable();
let mut bytes = Vec::with_capacity(16 + hashes.len() * 16);
bytes.extend_from_slice(&self.id.0.to_le_bytes());
for (name, change) in &hashes {
bytes.extend_from_slice(&name.to_le_bytes());
bytes.extend_from_slice(&change.to_le_bytes());
}
let id = EnvId(crate::cache::fnv1a64(&bytes));
Env {
frame: Some(Arc::new(Frame {
parent: self.frame.clone(),
changes,
})),
id,
}
}
pub fn get(&self, name: &str) -> Option<&Definition> {
match self.find(name)? {
Some(definition) => Some(definition),
None => None,
}
}
pub fn is_defined(&self, name: &str) -> bool {
self.get(name).is_some()
}
pub fn for_each_in_force(&self, mut visit: impl FnMut(&Definition)) {
let mut seen: std::collections::HashSet<&str> = std::collections::HashSet::new();
let mut frame = self.frame.as_deref();
while let Some(current) = frame {
for change in current.changes.iter().rev() {
if !seen.insert(change.name.as_ref()) {
continue;
}
if let Some(definition) = change.definition.as_deref() {
visit(definition);
}
}
frame = current.parent.as_deref();
}
}
pub fn len(&self) -> usize {
let mut count = 0;
self.for_each_in_force(|_| count += 1);
count
}
pub fn is_empty(&self) -> bool {
self.frame.is_none()
}
fn find(&self, name: &str) -> Option<Option<&Definition>> {
let mut frame = self.frame.as_deref();
while let Some(current) = frame {
for change in current.changes.iter().rev() {
if change.name.as_ref() == name {
return Some(change.definition.as_deref());
}
}
frame = current.parent.as_deref();
}
None
}
}
impl Default for Env {
fn default() -> Self {
Self::empty()
}
}
pub const MAX_ALIAS_HOPS: usize = 8;
pub struct Over<'a> {
env: Env,
seed: &'a dyn MacroValues,
}
impl<'a> Over<'a> {
fn the_seed_answer(&self, name: &str) -> Lookup<'_> {
match self.seed.lookup(name) {
Lookup::Undefined if !self.seed.is_complete() => Lookup::Unanswered,
answer => answer,
}
}
fn through_aliases<'s>(&'s self, definition: &'s Definition) -> Lookup<'s> {
if let Some(found) = definition.evaluable() {
return Lookup::Defined(found);
}
let mut alias = definition.alias();
for _ in 0..MAX_ALIAS_HOPS {
let Some(name) = alias else { break };
match self.env.get(name) {
Some(next) => {
if let Some(found) = next.evaluable() {
return Lookup::Defined(found);
}
alias = next.alias();
}
None => return self.the_seed_answer(name),
}
}
Lookup::DefinedWithoutAValue
}
pub fn new(env: Env, seed: &'a dyn MacroValues) -> Self {
Over { env, seed }
}
}
impl MacroValues for Over<'_> {
fn lookup(&self, name: &str) -> Lookup<'_> {
match self.env.find(name) {
Some(Some(definition)) => self.through_aliases(definition),
Some(None) => Lookup::Undefined,
None => self.the_seed_answer(name),
}
}
fn builtin_operator(&self, name: &str, operand: &str) -> Option<crate::Value> {
self.seed.builtin_operator(name, operand)
}
}
impl MacroValues for Env {
fn lookup(&self, name: &str) -> Lookup<'_> {
match self.find(name) {
Some(Some(_)) => Lookup::DefinedWithoutAValue,
Some(None) | None => Lookup::Undefined,
}
}
}
impl Change {
fn define(definition: Arc<Definition>) -> Self {
Self::new(Arc::from(definition.name()), Some(definition))
}
fn undef(name: &str) -> Self {
Self::new(Arc::from(name), None)
}
fn new(name: Arc<str>, definition: Option<Arc<Definition>>) -> Self {
let hash = match &definition {
Some(definition) => definition.hash(),
None => 0,
};
Change {
name,
definition,
hash,
}
}
}
fn hash_name(name: &str) -> u64 {
crate::cache::fnv1a64(name.as_bytes())
}
fn build_macro_def(
fact: &MacroFact,
text: &str,
body: Option<&str>,
) -> Option<crate::macros::MacroDef> {
if body.is_none() && !fact.function_like {
return None;
}
let params = if fact.function_like {
let start = fact.range.end_offset();
let end = fact.body_range.map_or(start, |range| range.start_offset);
Some(parameters_in(text.get(start..end).unwrap_or("")))
} else {
None
};
let body_text = body.unwrap_or("");
let value = fact
.value
.as_deref()
.and_then(|value| value.trim().parse::<i128>().ok());
let tokens: Vec<crate::token::Token> = if value.is_some() {
Vec::new()
} else {
let (lexed, _) = cpp_parser::lex(body_text, &cpp_parser::LexerConfig::default());
lexed
.iter()
.map(|data| {
let piece = body_text
.get(data.range.start_offset..data.range.end_offset())
.unwrap_or("");
crate::token::Token::new(data.kind, piece, data.range)
})
.collect()
};
let definition = crate::macros::MacroDef {
name: Box::from(fact.name.as_str()),
params,
body: crate::macros::MacroBody {
tokens,
stringize: Vec::new(),
paste: Vec::new(),
},
range: fact.range,
name_range: fact.range,
written_in: None,
value: std::sync::OnceLock::new(),
};
if let Some(number) = value {
let _ = definition.value.set(Some(number));
}
Some(definition)
}
fn parameters_in(list: &str) -> Vec<crate::macros::Parameter> {
let inner = list.trim();
let inner = inner.strip_prefix('(').unwrap_or(inner);
let inner = inner.strip_suffix(')').unwrap_or(inner);
if inner.trim().is_empty() {
return Vec::new();
}
inner
.split(',')
.map(|part| {
let part = part.trim();
if part == "..." {
crate::macros::Parameter {
name: Box::from("__VA_ARGS__"),
kind: crate::macros::ParameterKind::Variadic,
}
} else {
crate::macros::Parameter {
name: Box::from(part),
kind: crate::macros::ParameterKind::Ordinary,
}
}
})
.collect()
}