use cpp_parser::{CppTokenKind, LexerConfig, SourceRange, is_keyword};
use crate::{
condition::MacroValues,
macros::{MacroDef, ParameterKind},
token::{Token, is_trivia},
};
pub const MAX_DEPTH: usize = 128;
pub const MAX_TOKENS: usize = 100_000;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Origin {
Source,
Expanded { invocations: Vec<MacroInvocation> },
Pasted { call_site: SourceRange },
Stringized { call_site: SourceRange },
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct MacroInvocation {
pub name: Box<str>,
pub definition: SourceRange,
pub name_at: SourceRange,
pub call_site: SourceRange,
pub written_in: Option<crate::macros::MacroFile>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExpandedToken {
pub token: Token,
pub origin: Origin,
pub space_before: bool,
}
fn needs_a_separator(left: &Token, right: &Token) -> bool {
if left.text().is_empty() || right.text().is_empty() {
return false;
}
finishes_a_word(left.kind) && starts_a_word(right.kind)
}
fn finishes_a_word(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::Identifier
| CppTokenKind::IntegerLiteral
| CppTokenKind::FloatingLiteral
| CppTokenKind::StringLiteral
| CppTokenKind::CharLiteral
| CppTokenKind::UserDefinedLiteral
) || is_keyword(kind)
}
fn starts_a_word(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::Identifier
| CppTokenKind::IntegerLiteral
| CppTokenKind::FloatingLiteral
| CppTokenKind::StringLiteral
| CppTokenKind::CharLiteral
| CppTokenKind::UserDefinedLiteral
| CppTokenKind::Plus
| CppTokenKind::Minus
| CppTokenKind::Assign
| CppTokenKind::Less
| CppTokenKind::Greater
| CppTokenKind::Ampersand
| CppTokenKind::Pipe
| CppTokenKind::Dot
| CppTokenKind::Scope
) || is_keyword(kind)
}
impl ExpandedToken {
pub fn kind(&self) -> CppTokenKind {
self.token.kind
}
pub fn text(&self) -> &str {
self.token.text()
}
pub fn diagnostic_range(&self) -> SourceRange {
match &self.origin {
Origin::Source => self.token.range,
Origin::Expanded { invocations } => invocations
.first()
.map(|invocation| invocation.call_site)
.unwrap_or(self.token.range),
Origin::Pasted { call_site } | Origin::Stringized { call_site } => *call_site,
}
}
pub fn navigation_at(&self) -> Option<(crate::macros::MacroFile, SourceRange)> {
match &self.origin {
Origin::Expanded { invocations } => invocations.iter().rev().find_map(|invocation| {
invocation.written_in.map(|file| (file, invocation.name_at))
}),
_ => Some((crate::macros::MacroFile::Here, self.token.range)),
}
}
pub fn is_expanded(&self) -> bool {
!matches!(self.origin, Origin::Source)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExpansionNote {
NoArgumentList { name: Box<str> },
UnterminatedArgumentList { name: Box<str> },
WrongArgumentCount {
name: Box<str>,
expected: usize,
found: usize,
},
Recursive { name: Box<str> },
TooDeep { name: Box<str> },
BudgetExhausted,
EmptyPaste,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Diagnostic {
pub note: ExpansionNote,
pub range: SourceRange,
}
#[derive(Debug, Clone, Default)]
pub struct Expansion {
pub tokens: Vec<ExpandedToken>,
pub diagnostics: Vec<Diagnostic>,
pub exhausted: bool,
}
impl Expansion {
pub fn plain(&self) -> Vec<Token> {
self.tokens.iter().map(|it| it.token.clone()).collect()
}
pub fn is_empty(&self) -> bool {
self.tokens.is_empty()
}
}
pub fn expand(tokens: &[Token], macros: &(impl MacroValues + ?Sized)) -> Expansion {
let mut expander = Expander {
macros,
active: Vec::new(),
invocations: Vec::new(),
depth: 0,
budget: MAX_TOKENS,
out: Vec::new(),
diagnostics: Vec::new(),
exhausted: false,
};
let marked: Vec<Marked> = tokens.iter().cloned().map(Marked::from).collect();
let region = span_of(tokens);
expander.expand_into(&marked, region, None);
expander.finish()
}
pub fn expand_with_budget(
tokens: &[Token],
macros: &(impl MacroValues + ?Sized),
budget: usize,
) -> Expansion {
let mut expander = Expander {
macros,
active: Vec::new(),
invocations: Vec::new(),
depth: 0,
budget,
out: Vec::new(),
diagnostics: Vec::new(),
exhausted: false,
};
let marked: Vec<Marked> = tokens.iter().cloned().map(Marked::from).collect();
let region = span_of(tokens);
expander.expand_into(&marked, region, None);
expander.finish()
}
struct Expander<'a, M: MacroValues + ?Sized> {
macros: &'a M,
active: Vec<Box<str>>,
invocations: Vec<MacroInvocation>,
depth: usize,
budget: usize,
out: Vec<ExpandedToken>,
diagnostics: Vec<Diagnostic>,
exhausted: bool,
}
impl<M: MacroValues + ?Sized> Expander<'_, M> {
fn finish(self) -> Expansion {
Expansion {
tokens: self.out,
diagnostics: self.diagnostics,
exhausted: self.exhausted,
}
}
fn note(&mut self, note: ExpansionNote, range: SourceRange) {
if self.diagnostics.len() < 32 {
self.diagnostics.push(Diagnostic { note, range });
}
}
fn origin_of(&self, token: &Token, region: Option<SourceRange>, fallback: &Origin) -> Origin {
if matches!(fallback, Origin::Pasted { .. } | Origin::Stringized { .. }) {
return fallback.clone();
}
if matches!(fallback, Origin::Expanded { invocations } if !invocations.is_empty()) {
return fallback.clone();
}
if matches!(fallback, Origin::Expanded { invocations } if invocations.is_empty()) {
return Origin::Expanded {
invocations: self.invocations.clone(),
};
}
let Some(region) = region else {
return fallback.clone();
};
if token.range.start_offset >= region.start_offset
&& token.range.end_offset() <= region.end_offset()
{
return fallback.clone();
}
Origin::Expanded {
invocations: self.invocations.clone(),
}
}
fn space_before(&self, previous: &Token, token: &Token) -> bool {
let same_file = match self.invocations.last() {
None => true,
Some(invocation) => {
let site = invocation.call_site;
let in_site = |range: SourceRange| {
range.start_offset >= site.start_offset
&& range.end_offset() <= site.end_offset()
};
in_site(previous.range) == in_site(token.range)
}
};
let separated_in_source =
same_file && previous.range.end_offset() < token.range.start_offset;
separated_in_source || needs_a_separator(previous, token)
}
fn push(&mut self, token: Token, origin: Origin, region: Option<SourceRange>) -> bool {
let origin = self.origin_of(&token, region, &origin);
if self.budget == 0 {
self.exhausted = true;
return false;
}
self.budget -= 1;
let space_before = match self.out.last() {
None => false,
Some(previous) => self.space_before(&previous.token, &token),
};
self.out.push(ExpandedToken {
token,
origin,
space_before,
});
true
}
fn expand_into(
&mut self,
tokens: &[Marked],
region: Option<SourceRange>,
tail: Option<&Tail<'_>>,
) -> usize {
let mut index = 0;
let mut consumed = 0usize;
while index < tokens.len() {
if self.exhausted {
return consumed;
}
let token = &tokens[index].token;
if !could_be_a_macro_name(token.kind) {
if !self.push(token.clone(), tokens[index].origin.clone(), region) {
return consumed;
}
index += 1;
continue;
}
let Some(definition) = self.macros.lookup(token.text()).definition() else {
if !self.push(token.clone(), tokens[index].origin.clone(), region) {
return consumed;
}
index += 1;
continue;
};
let definition = definition.clone();
let name: Box<str> = token.text.as_str().into();
if self.active.contains(&name) {
self.note(ExpansionNote::Recursive { name: name.clone() }, token.range);
if !self.push(token.clone(), tokens[index].origin.clone(), region) {
return consumed;
}
index += 1;
continue;
}
if self.depth >= MAX_DEPTH {
self.note(ExpansionNote::TooDeep { name: name.clone() }, token.range);
if !self.push(token.clone(), tokens[index].origin.clone(), region) {
return consumed;
}
index += 1;
continue;
}
match &definition.params {
None => {
let invocation = MacroInvocation {
name: name.clone(),
definition: definition.range,
name_at: definition.name_range,
call_site: token.range,
written_in: definition.written_in,
};
let after = Tail {
tokens: &tokens[index + 1..],
outer: tail,
};
let used = self.expand_body(&definition, &[], tokens, invocation, Some(&after));
index += 1;
self.advance_past(tokens.len(), &mut index, used, &mut consumed);
}
Some(_) => {
let open = match tokens[index + 1..]
.iter()
.position(|marked| !is_trivia(marked.token.kind))
{
Some(offset) => (tokens[index + 1 + offset].token.kind
== CppTokenKind::LeftParen)
.then_some(index + 1 + offset),
None => None,
};
let reaches_into_the_tail = tokens[index + 1..]
.iter()
.all(|marked| is_trivia(marked.token.kind))
&& tail.is_some_and(Tail::starts_a_call);
if open.is_none() && !reaches_into_the_tail {
self.note(
ExpansionNote::NoArgumentList { name: name.clone() },
token.range,
);
if !self.push(token.clone(), tokens[index].origin.clone(), region) {
return consumed;
}
index += 1;
continue;
}
let flat: Vec<Marked>;
let (source, in_this_run, open) = match open {
Some(open) => (tokens, true, open),
None => {
let mut run = tokens[index..].to_vec();
if let Some(tail) = tail {
tail.copy_into(&mut run);
}
let open = run
.iter()
.skip(1)
.position(|marked| !is_trivia(marked.token.kind))
.map_or(1, |offset| offset + 1);
flat = run;
(flat.as_slice(), false, open)
}
};
let Some(arguments) = split_arguments(source, open) else {
self.note(
ExpansionNote::UnterminatedArgumentList { name: name.clone() },
token.range,
);
if !self.push(token.clone(), tokens[index].origin.clone(), region) {
return consumed;
}
index += 1;
continue;
};
if !definition.accepts_argument_count(arguments.groups.len()) {
self.note(
ExpansionNote::WrongArgumentCount {
name: name.clone(),
expected: expected_arguments(&definition),
found: arguments.groups.len(),
},
token.range,
);
if !self.push(token.clone(), tokens[index].origin.clone(), region) {
return consumed;
}
index += 1;
continue;
}
let call_from = if in_this_run {
token.range.start_offset
} else {
source[open].token.range.start_offset
};
let length = arguments.end_offset.saturating_sub(call_from);
let call_site = SourceRange::new(call_from, length);
let invocation = MacroInvocation {
name: name.clone(),
definition: definition.range,
name_at: definition.name_range,
call_site,
written_in: definition.written_in,
};
if in_this_run {
let after = Tail {
tokens: &source[arguments.next_index..],
outer: tail,
};
let used = self.expand_body(
&definition,
&arguments.groups,
source,
invocation,
Some(&after),
);
index = arguments.next_index;
self.advance_past(tokens.len(), &mut index, used, &mut consumed);
} else {
let own = tokens.len() - index;
let after = Tail {
tokens: &source[arguments.next_index..],
outer: None,
};
let used = self.expand_body(
&definition,
&arguments.groups,
source,
invocation,
Some(&after),
);
consumed = arguments.next_index - own + used;
index = tokens.len();
}
}
}
}
consumed
}
fn expand_arguments(
&mut self,
definition: &MacroDef,
arguments: &[std::ops::Range<usize>],
plain: &[Token],
region: Option<SourceRange>,
) -> Vec<Option<Vec<Marked>>> {
let Some(params) = &definition.params else {
return Vec::new();
};
let mut expanded = Vec::with_capacity(params.len());
for param in params {
let raw = trim_trivia(argument_range_for(params, arguments, plain, ¶m.name));
let has_a_macro = raw.iter().any(|token| {
could_be_a_macro_name(token.kind)
&& self.macros.lookup(token.text()).definition().is_some()
});
if !has_a_macro {
expanded.push(None);
continue;
}
let marked: Vec<Marked> = raw.into_iter().map(Marked::from).collect();
let saved = std::mem::take(&mut self.out);
self.expand_into(&marked, region, None);
let produced = std::mem::replace(&mut self.out, saved);
let mut tokens: Vec<Marked> = produced
.into_iter()
.map(|token| Marked {
token: token.token,
origin: token.origin,
})
.collect();
while tokens
.last()
.is_some_and(|marked| is_trivia(marked.token.kind))
{
tokens.pop();
}
let leading = tokens
.iter()
.take_while(|marked| is_trivia(marked.token.kind))
.count();
tokens.drain(..leading);
expanded.push(Some(tokens));
}
expanded
}
fn advance_past(&self, length: usize, index: &mut usize, used: usize, consumed: &mut usize) {
let available = length - *index;
if used <= available {
*index += used;
} else {
*index = length;
*consumed = used - available;
}
}
fn expand_body(
&mut self,
definition: &MacroDef,
arguments: &[std::ops::Range<usize>],
tokens: &[Marked],
invocation: MacroInvocation,
after: Option<&Tail<'_>>,
) -> usize {
let (offset, wanted) = match (arguments.first(), arguments.last()) {
(Some(first), Some(last)) => (first.start, &tokens[first.start..last.end]),
_ => (0, &tokens[..0]),
};
let plain: Vec<Token> = wanted.iter().map(|marked| marked.token.clone()).collect();
let arguments: Vec<std::ops::Range<usize>> = arguments
.iter()
.map(|range| range.start - offset..range.end - offset)
.collect();
let arguments = arguments.as_slice();
let region = Some(invocation.call_site);
let expanded = self.expand_arguments(definition, arguments, &plain, region);
self.active.push(definition.name.clone());
self.invocations.push(invocation.clone());
self.depth += 1;
let mut operators_at = invocation.clone();
if let Some(outermost) = self.invocations.first() {
operators_at.call_site = outermost.call_site;
}
let substituted = substitute(definition, arguments, &plain, &operators_at, &expanded);
let used = self.expand_into(&substituted, region, after);
self.depth -= 1;
self.active.pop();
self.invocations.pop();
used
}
}
struct Tail<'a> {
tokens: &'a [Marked],
outer: Option<&'a Tail<'a>>,
}
impl Tail<'_> {
fn starts_a_call(&self) -> bool {
let mut at = Some(self);
while let Some(run) = at {
if let Some(next) = run
.tokens
.iter()
.find(|marked| !is_trivia(marked.token.kind))
{
return next.token.kind == CppTokenKind::LeftParen;
}
at = run.outer;
}
false
}
fn copy_into(&self, out: &mut Vec<Marked>) {
let mut at = Some(self);
while let Some(run) = at {
out.extend(run.tokens.iter().cloned());
at = run.outer;
}
}
}
struct Arguments {
groups: Vec<std::ops::Range<usize>>,
next_index: usize,
end_offset: usize,
}
fn span_of(tokens: &[Token]) -> Option<SourceRange> {
let first = tokens.first()?;
let last = tokens.last()?;
Some(SourceRange::new(
first.range.start_offset,
last.range.end_offset() - first.range.start_offset,
))
}
#[derive(Clone)]
struct Marked {
token: Token,
origin: Origin,
}
impl From<Token> for Marked {
fn from(token: Token) -> Self {
Marked {
token,
origin: Origin::Source,
}
}
}
impl Marked {
fn from_a_body(token: Token) -> Self {
Marked {
token,
origin: Origin::Expanded {
invocations: Vec::new(),
},
}
}
}
impl FromIterator<Marked> for Vec<Token> {
fn from_iter<T: IntoIterator<Item = Marked>>(iter: T) -> Self {
iter.into_iter().map(|marked| marked.token).collect()
}
}
fn split_arguments(tokens: &[Marked], open: usize) -> Option<Arguments> {
let mut depth = 0usize;
let mut groups: Vec<std::ops::Range<usize>> = Vec::new();
let mut group_start = open + 1;
let mut cursor = open;
let mut saw_a_comma = false;
while cursor < tokens.len() {
let token = &tokens[cursor].token;
match token.kind {
CppTokenKind::LeftParen => depth += 1,
CppTokenKind::RightParen => {
depth -= 1;
if depth == 0 {
if saw_a_comma || group_has_content(tokens, group_start..cursor) {
groups.push(group_start..cursor);
}
return Some(Arguments {
groups,
next_index: cursor + 1,
end_offset: token.range.end_offset(),
});
}
}
CppTokenKind::Comma if depth == 1 => {
groups.push(group_start..cursor);
group_start = cursor + 1;
saw_a_comma = true;
}
_ => {}
}
cursor += 1;
}
None
}
fn group_has_content(tokens: &[Marked], range: std::ops::Range<usize>) -> bool {
tokens
.get(range)
.is_some_and(|slice| slice.iter().any(|marked| !is_trivia(marked.token.kind)))
}
fn expected_arguments(definition: &MacroDef) -> usize {
definition
.params
.as_ref()
.map(|params| params.len())
.unwrap_or(0)
}
fn substitute(
definition: &MacroDef,
arguments: &[std::ops::Range<usize>],
tokens: &[Token],
invocation: &MacroInvocation,
expanded: &[Option<Vec<Marked>>],
) -> Vec<Marked> {
let Some(params) = &definition.params else {
return significant_tokens(&definition.body.tokens)
.into_iter()
.map(Marked::from_a_body)
.collect();
};
let body_tokens = significant_tokens(&definition.body.tokens);
let stringize_at = remap_positions(&definition.body.stringize, &definition.body.tokens);
let paste_at = remap_positions(&definition.body.paste, &definition.body.tokens);
let mut out: Vec<Marked> = Vec::with_capacity(body_tokens.len());
let mut index = 0;
while index < body_tokens.len() {
let token = &body_tokens[index];
if token.kind == CppTokenKind::Identifier
&& token.text() == "__VA_OPT__"
&& body_tokens
.get(index + 1)
.is_some_and(|next| next.kind == CppTokenKind::LeftParen)
{
let open = index + 1;
let Some(close) = matching_close(&body_tokens, open) else {
out.extend(
body_tokens[index..]
.iter()
.cloned()
.map(Marked::from_a_body),
);
return out;
};
if variadic_argument_is_empty(params, arguments, tokens) {
index = close + 1;
continue;
}
let inside = |positions: &[usize]| -> Vec<usize> {
positions
.iter()
.filter(|at| **at > open && **at < close)
.map(|at| at - (open + 1))
.collect()
};
let mut group = definition.clone();
group.body = crate::macros::MacroBody {
tokens: body_tokens[open + 1..close].to_vec(),
stringize: inside(&stringize_at),
paste: inside(&paste_at),
};
out.extend(substitute(&group, arguments, tokens, invocation, expanded));
index = close + 1;
continue;
}
if stringize_at.contains(&index)
&& token.kind == CppTokenKind::Hash
&& let Some(name_index) = (index + 1..body_tokens.len()).next()
&& is_parameter(params, body_tokens[name_index].text())
{
let name = body_tokens[name_index].text();
let argument = argument_for(params, arguments, tokens, name);
out.push(Marked {
token: stringize(&argument, invocation.call_site),
origin: Origin::Stringized {
call_site: invocation.call_site,
},
});
index = name_index + 1;
continue;
}
if paste_at.contains(&index) {
let right_index = (index + 1..body_tokens.len()).next();
let Some(right_index) = right_index else {
index += 1;
continue;
};
let left = out.pop();
let right = if is_parameter(params, body_tokens[right_index].text()) {
argument_for(params, arguments, tokens, body_tokens[right_index].text())
.into_iter()
.next()
.map(Marked::from)
} else {
Some(Marked::from_a_body(body_tokens[right_index].clone()))
};
match (left, right) {
(Some(left), Some(right)) => {
let mut pasted = paste(&left.token, &right.token);
if let Some(first) = pasted.first_mut() {
first.origin = Origin::Pasted {
call_site: invocation.call_site,
};
}
out.extend(pasted);
}
(Some(left), None) => out.push(left),
(None, Some(right)) => out.push(right),
(None, None) => {}
}
index = right_index + 1;
continue;
}
if is_parameter(params, token.text()) {
let pre_expanded = params
.iter()
.position(|param| &*param.name == token.text())
.filter(|_| !paste_at.contains(&(index + 1)))
.and_then(|position| expanded.get(position))
.and_then(|argument| argument.as_ref());
match pre_expanded {
Some(argument) => out.extend(argument.iter().cloned()),
None => {
let argument = argument_for(params, arguments, tokens, token.text());
out.extend(argument.into_iter().map(Marked::from));
}
}
index += 1;
continue;
}
out.push(Marked::from_a_body(token.clone()));
index += 1;
}
out
}
fn matching_close(tokens: &[Token], open: usize) -> Option<usize> {
let mut depth = 0usize;
for (index, token) in tokens.iter().enumerate().skip(open) {
match token.kind {
CppTokenKind::LeftParen => depth += 1,
CppTokenKind::RightParen => {
depth = depth.saturating_sub(1);
if depth == 0 {
return Some(index);
}
}
_ => {}
}
}
None
}
fn variadic_argument_is_empty(
params: &[crate::macros::Parameter],
arguments: &[std::ops::Range<usize>],
tokens: &[Token],
) -> bool {
argument_for(params, arguments, tokens, "__VA_ARGS__").is_empty()
}
fn remap_positions(positions: &[usize], body: &[Token]) -> Vec<usize> {
positions
.iter()
.filter_map(|position| {
let significant_before = body
.get(..*position)
.map(|before| before.iter().filter(|token| !is_trivia(token.kind)).count())
.unwrap_or(0);
body.get(*position)
.filter(|token| !is_trivia(token.kind))
.map(|_| significant_before)
})
.collect()
}
fn significant_tokens(tokens: &[Token]) -> Vec<Token> {
tokens
.iter()
.filter(|token| !is_trivia(token.kind))
.cloned()
.collect()
}
fn trim_trivia(tokens: Vec<Token>) -> Vec<Token> {
let start = tokens
.iter()
.position(|token| !is_trivia(token.kind))
.unwrap_or(tokens.len());
let end = tokens
.iter()
.rposition(|token| !is_trivia(token.kind))
.map(|index| index + 1)
.unwrap_or(start);
tokens[start.min(end)..end].to_vec()
}
fn argument_for(
params: &[crate::macros::Parameter],
arguments: &[std::ops::Range<usize>],
tokens: &[Token],
name: &str,
) -> Vec<Token> {
trim_trivia(argument_range_for(params, arguments, tokens, name))
}
fn argument_range_for(
params: &[crate::macros::Parameter],
arguments: &[std::ops::Range<usize>],
tokens: &[Token],
name: &str,
) -> Vec<Token> {
let Some(position) = params.iter().position(|param| &*param.name == name) else {
return Vec::new();
};
let is_variadic = params[position].kind == ParameterKind::Variadic;
let range = if is_variadic {
let Some(first) = arguments.get(position) else {
return Vec::new();
};
let last_end = arguments.last().map(|range| range.end).unwrap_or(first.end);
first.start..last_end
} else {
match arguments.get(position) {
Some(range) => range.clone(),
None => return Vec::new(),
}
};
let Some(slice) = tokens.get(range) else {
return Vec::new();
};
if is_variadic && arguments.len() > position + 1 {
let mut joined = Vec::new();
for (offset, argument) in arguments[position..].iter().enumerate() {
if offset > 0 {
joined.push(synthetic_comma(tokens, argument.start));
}
if let Some(piece) = tokens.get(argument.clone()) {
joined.extend_from_slice(piece);
}
}
return joined;
}
slice.to_vec()
}
fn synthetic_comma(tokens: &[Token], near: usize) -> Token {
let range = tokens
.get(near)
.map(|token| SourceRange::new(token.range.start_offset, 1))
.unwrap_or_else(|| SourceRange::new(0, 1));
Token::new(CppTokenKind::Comma, ",", range)
}
fn stringize(argument: &[Token], call_site: SourceRange) -> Token {
let mut text = String::with_capacity(argument.len() * 4 + 2);
text.push('"');
let mut previous: Option<&Token> = None;
let mut saw_layout = false;
for token in argument.iter() {
if is_trivia(token.kind) {
saw_layout = true;
continue;
}
if let Some(previous) = previous
&& (saw_layout || previous.range.end_offset() != token.range.start_offset)
{
text.push(' ');
}
saw_layout = false;
previous = Some(token);
for character in token.text().chars() {
match character {
'"' => text.push_str("\\\""),
'\\' => text.push_str("\\\\"),
other => text.push(other),
}
}
}
text.push('"');
Token::new(CppTokenKind::StringLiteral, text, call_site)
}
fn paste(left: &Token, right: &Token) -> Vec<Marked> {
let joined = format!("{}{}", left.text(), right.text());
let range = left.range;
let lexed = lex_fragment(&joined, range);
match lexed {
Some(mut tokens) if tokens.len() == 1 => {
let mut token = tokens.remove(0);
token.range = range;
vec![Marked::from(token)]
}
_ => vec![Marked::from(left.clone()), Marked::from(right.clone())],
}
}
fn lex_fragment(text: &str, _range: SourceRange) -> Option<Vec<Token>> {
let mut errors = Vec::new();
let mut lexer = cpp_parser::CppLexer::new(text, LexerConfig::default(), &mut errors);
let data = lexer.tokenize();
if data.is_empty() {
return None;
}
Some(
data.into_iter()
.map(|token| {
Token::new(
token.kind,
&text[token.range.start_offset..token.range.end_offset()],
token.range,
)
})
.collect(),
)
}
fn is_parameter(params: &[crate::macros::Parameter], name: &str) -> bool {
params.iter().any(|param| &*param.name == name)
}
pub fn could_be_a_macro_name(kind: CppTokenKind) -> bool {
kind == CppTokenKind::Identifier || is_keyword(kind)
}