use cpp_parser::{CppTokenKind, SourceRange};
use crate::token::{Token, is_trivia};
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Parameter {
pub name: Box<str>,
pub kind: ParameterKind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ParameterKind {
Ordinary,
Variadic,
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct MacroBody {
pub tokens: Vec<Token>,
pub stringize: Vec<usize>,
pub paste: Vec<usize>,
}
impl MacroBody {
pub fn is_empty(&self) -> bool {
self.tokens
.iter()
.all(|token| is_trivia(token.kind) || token.kind == CppTokenKind::None)
}
pub fn significant(&self) -> impl Iterator<Item = &Token> {
self.tokens.iter().filter(|token| !is_trivia(token.kind))
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MacroDef {
pub name: Box<str>,
pub params: Option<Vec<Parameter>>,
pub body: MacroBody,
pub range: SourceRange,
pub name_range: SourceRange,
pub written_in: Option<MacroFile>,
pub value: std::sync::OnceLock<Option<i128>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MacroFile {
Here,
Frame(u32),
}
impl MacroDef {
pub fn is_function_like(&self) -> bool {
self.params.is_some()
}
pub fn is_variadic(&self) -> bool {
self.params
.as_ref()
.is_some_and(|params| params.iter().any(|p| p.kind == ParameterKind::Variadic))
}
pub fn min_arguments(&self) -> usize {
match &self.params {
None => 0,
Some(params) => params
.iter()
.filter(|p| p.kind == ParameterKind::Ordinary)
.count(),
}
}
pub fn accepts_argument_count(&self, count: usize) -> bool {
match &self.params {
None => false,
Some(params) => {
if self.is_variadic() {
count >= self.min_arguments()
} else {
count == params.len()
}
}
}
}
}
#[derive(Debug, Clone)]
struct Binding {
name: Box<str>,
definition: Option<std::sync::Arc<MacroDef>>,
at: usize,
}
pub trait UnitSources {
fn source_of(&self, path: &std::path::Path) -> Option<&str>;
}
impl<S: std::borrow::Borrow<str>> UnitSources for std::collections::HashMap<std::path::PathBuf, S> {
fn source_of(&self, path: &std::path::Path) -> Option<&str> {
self.get(path).map(|text| text.borrow())
}
}
pub trait MacroBindings {
fn definition_at(&self, name: &str, offset: usize) -> Option<&MacroDef>;
fn definition(&self, name: &str) -> Option<&MacroDef>;
fn builtin_operator(&self, name: &str, operand: &str) -> Option<crate::condition::Value> {
let _ = (name, operand);
None
}
}
impl MacroBindings for MacroTable {
fn definition_at(&self, name: &str, offset: usize) -> Option<&MacroDef> {
self.get_at(name, offset)
}
fn definition(&self, name: &str) -> Option<&MacroDef> {
self.get(name)
}
}
#[derive(Debug, Clone, Default)]
pub struct MacroTable {
bindings: Vec<Binding>,
by_name: std::collections::HashMap<Box<str>, Vec<u32>>,
}
impl MacroTable {
pub fn new() -> Self {
Self::default()
}
pub fn from_marked(marked: &crate::Marked) -> Self {
let mut table = MacroTable::new();
for name in marked.defined_names() {
if let Some(definition) = marked.get(&name) {
table.define(definition.clone());
}
}
table
}
fn index(&mut self, name: &str) {
let index = (self.bindings.len() - 1) as u32;
self.by_name.entry(Box::from(name)).or_default().push(index);
}
pub fn define(&mut self, definition: MacroDef) {
self.define_shared(std::sync::Arc::new(definition));
}
pub fn define_shared(&mut self, definition: std::sync::Arc<MacroDef>) {
let at = definition.range.start_offset;
self.define_shared_at(definition, at);
}
pub fn define_shared_at(&mut self, definition: std::sync::Arc<MacroDef>, at: usize) {
self.bindings.push(Binding {
at,
name: definition.name.clone(),
definition: Some(std::sync::Arc::clone(&definition)),
});
self.index(&definition.name);
}
pub fn undefine(&mut self, name: &str, at: usize) {
self.bindings.push(Binding {
name: name.into(),
definition: None,
at,
});
self.index(name);
}
pub fn extend_from(&mut self, other: &MacroTable) {
let first = self.bindings.len() as u32;
self.bindings
.extend(other.bindings.iter().map(|binding| Binding {
name: binding.name.clone(),
definition: binding.definition.clone(),
at: binding.at,
}));
for (name, indices) in &other.by_name {
self.by_name
.entry(name.clone())
.or_default()
.extend(indices.iter().map(|index| index + first));
}
}
fn binding_at(&self, name: &str, offset: Option<usize>) -> Option<&Binding> {
let indices = self.by_name.get(name)?;
indices
.iter()
.rev()
.map(|index| &self.bindings[*index as usize])
.find(|binding| offset.is_none_or(|offset| binding.at <= offset))
}
pub fn get(&self, name: &str) -> Option<&MacroDef> {
self.binding_at(name, None)?.definition.as_deref()
}
pub fn get_at(&self, name: &str, offset: usize) -> Option<&MacroDef> {
self.binding_at(name, Some(offset))?.definition.as_deref()
}
pub fn is_defined(&self, name: &str) -> bool {
self.get(name).is_some()
}
pub fn is_defined_at(&self, name: &str, offset: usize) -> bool {
self.get_at(name, offset).is_some()
}
pub fn iter(&self) -> impl Iterator<Item = &MacroDef> {
self.bindings
.iter()
.rev()
.filter_map(|binding| binding.definition.as_deref())
}
pub fn defined_names(&self) -> Vec<&str> {
let mut names: Vec<&str> = self
.bindings
.iter()
.rev()
.filter(|binding| binding.definition.is_some())
.map(|binding| &*binding.name)
.collect();
names.sort_unstable();
names.dedup();
names
}
pub fn len(&self) -> usize {
self.defined_names().len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
}
pub fn parse_define(tokens: &[Token], range: SourceRange) -> Option<MacroDef> {
let mut index = 0;
skip_trivia(tokens, &mut index);
let name_token = tokens.get(index)?;
if !could_be_a_macro_name(name_token.kind) {
return None;
}
let name_range = name_token.range;
let name = name_token.text.clone();
index += 1;
let params = parse_parameters(tokens, &mut index);
let body = parse_body(tokens, index, ¶ms);
Some(MacroDef {
name,
params,
body,
range,
name_range,
written_in: Some(MacroFile::Here),
value: std::sync::OnceLock::new(),
})
}
fn could_be_a_macro_name(kind: CppTokenKind) -> bool {
kind == CppTokenKind::Identifier
|| kind == CppTokenKind::TrueKeyword
|| kind == CppTokenKind::FalseKeyword
|| crate::token::is_keyword_like(kind)
}
fn parse_parameters(tokens: &[Token], index: &mut usize) -> Option<Vec<Parameter>> {
let open = tokens.get(*index)?;
if open.kind != CppTokenKind::LeftParen {
return None;
}
*index += 1;
let mut params: Vec<Parameter> = Vec::new();
loop {
skip_trivia(tokens, index);
let Some(token) = tokens.get(*index) else {
return None;
};
match token.kind {
CppTokenKind::RightParen => {
*index += 1;
return Some(params);
}
CppTokenKind::Identifier => {
params.push(Parameter {
name: token.text.clone(),
kind: ParameterKind::Ordinary,
});
*index += 1;
}
CppTokenKind::Ellipsis => {
params.push(Parameter {
name: "__VA_ARGS__".into(),
kind: ParameterKind::Variadic,
});
*index += 1;
}
_ => return None,
}
skip_trivia(tokens, index);
match tokens.get(*index).map(|token| token.kind) {
Some(CppTokenKind::Comma) => {
*index += 1;
}
Some(CppTokenKind::RightParen) => {}
Some(CppTokenKind::Ellipsis) => {
if let Some(last) = params.last_mut() {
last.kind = ParameterKind::Variadic;
}
*index += 1;
}
_ => return None,
}
}
}
fn parse_body(tokens: &[Token], start: usize, params: &Option<Vec<Parameter>>) -> MacroBody {
let mut body = MacroBody::default();
let mut index = start;
while let Some(token) = tokens.get(index) {
index += 1;
if is_dropped_in_a_body(token.kind) {
continue;
}
match token.kind {
CppTokenKind::Hash => {
let mut lookahead = index;
skip_trivia(tokens, &mut lookahead);
let is_operator = tokens
.get(lookahead)
.is_some_and(|next| is_parameter(params, next.text()));
if is_operator {
body.stringize.push(body.tokens.len());
}
body.tokens.push(token.clone());
}
CppTokenKind::HashHash => {
body.paste.push(body.tokens.len());
body.tokens.push(token.clone());
}
_ => body.tokens.push(token.clone()),
}
}
body
}
fn is_dropped_in_a_body(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::LineComment
| CppTokenKind::BlockComment
| CppTokenKind::LineContinuation
| CppTokenKind::None
| CppTokenKind::Eof
)
}
fn is_parameter(params: &Option<Vec<Parameter>>, name: &str) -> bool {
params.as_ref().is_some_and(|params| {
params
.iter()
.any(|param| &*param.name == name || name == "__VA_ARGS__")
})
}
fn skip_trivia(tokens: &[Token], index: &mut usize) {
while tokens
.get(*index)
.is_some_and(|token| is_trivia(token.kind))
{
*index += 1;
}
}