use alloc::vec::Vec;
use core::fmt;
use token_lang::Span;
use crate::context::Hygiene;
use crate::matcher::{Matcher, Outcome};
use crate::transcribe::{Expansion, Scratch, transcribe};
use crate::{Budget, Context, ExpandError, Limit, Macro, Origin, Tree, Usage};
pub struct Expander<K> {
hygiene: Hygiene,
matcher: Matcher<K>,
scratch: Scratch<K>,
budget: Budget,
usage: Usage,
}
impl<K> Expander<K> {
pub const DEFAULT_LIMIT: u32 = Budget::DEFAULT.max_depth;
#[must_use]
pub fn new() -> Self {
Self::with_budget(Budget::DEFAULT)
}
#[must_use]
pub fn with_limit(limit: u32) -> Self {
Self::with_budget(Budget::DEFAULT.with_max_depth(limit))
}
#[must_use]
pub fn with_budget(budget: Budget) -> Self {
Self {
hygiene: Hygiene::default(),
matcher: Matcher::default(),
scratch: Scratch::default(),
budget,
usage: Usage::NONE,
}
}
#[inline]
#[must_use]
pub const fn limit(&self) -> u32 {
self.budget.max_depth
}
#[inline]
#[must_use]
pub const fn budget(&self) -> Budget {
self.budget
}
#[inline]
pub fn set_budget(&mut self, budget: Budget) {
self.budget = budget;
}
#[inline]
#[must_use]
pub const fn usage(&self) -> Usage {
self.usage
}
#[inline]
pub fn reset_usage(&mut self) {
self.usage = Usage::NONE;
}
#[inline]
#[must_use]
pub fn origin(&self, ctx: Context) -> Option<Origin> {
self.hygiene.origin(ctx)
}
}
impl<K: Clone + PartialEq> Expander<K> {
#[inline]
pub fn expand(
&mut self,
mac: &Macro<K>,
input: &[Tree<K>],
call_site: Span,
call_context: Context,
) -> Result<Vec<Tree<K>>, ExpandError> {
self.expand_at(mac, input, call_site, call_context, 0)
}
pub fn expand_at(
&mut self,
mac: &Macro<K>,
input: &[Tree<K>],
call_site: Span,
call_context: Context,
depth: u32,
) -> Result<Vec<Tree<K>>, ExpandError> {
self.matcher.load(input);
let depth = self.depth_of(call_context, depth).saturating_add(1);
if depth > self.budget.max_depth {
return Err(ExpandError::RecursionLimit {
limit: self.budget.max_depth,
});
}
if self.usage.expansions >= self.budget.max_expansions {
return Err(ExpandError::Budget(Limit::Expansions {
max: self.budget.max_expansions,
}));
}
let mut furthest = 0;
for (index, rule) in mac.rules().iter().enumerate() {
match self.matcher.run(rule) {
Outcome::Match => {
let checkpoint = self.hygiene.checkpoint();
let expansion = self
.hygiene
.begin(mac.name(), call_site, call_context, depth);
let result = transcribe(
Expansion {
rule,
index,
matcher: &self.matcher,
hygiene: &mut self.hygiene,
expansion,
tokens_left: self.budget.max_tokens.saturating_sub(self.usage.tokens),
tokens_max: self.budget.max_tokens,
},
&mut self.scratch,
);
return match result {
Ok((out, written)) => {
self.usage.tokens = self.usage.tokens.saturating_add(written);
self.usage.expansions = self.usage.expansions.saturating_add(1);
Ok(out)
}
Err(err) => {
self.hygiene.rollback(checkpoint);
Err(err)
}
};
}
Outcome::Ambiguous => return Err(ExpandError::Ambiguous { rule: index }),
Outcome::NoMatch { furthest: reached } => furthest = furthest.max(reached),
}
}
Err(ExpandError::NoMatch {
span: self.matcher.span_at(furthest, call_site),
})
}
fn depth_of(&self, call_context: Context, depth: u32) -> u32 {
let mut deepest = depth.max(self.hygiene.depth(call_context));
if self.matcher.marked {
let mut last = Context::ROOT;
for ctx in self.matcher.contexts() {
if ctx != last {
deepest = deepest.max(self.hygiene.depth(ctx));
last = ctx;
}
}
}
deepest
}
}
impl<K> Default for Expander<K> {
fn default() -> Self {
Self::new()
}
}
impl<K> fmt::Debug for Expander<K> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (contexts, expansions) = self.hygiene.sizes();
f.debug_struct("Expander")
.field("limit", &self.budget.max_depth)
.field("contexts", &contexts)
.field("expansions", &expansions)
.finish()
}
}