use cpp_parser::{CppTokenData, CppTokenKind};
use super::{FormatConfig, FormatKind, FormatLiteral, pieces_in};
pub fn literals_in(
source: &str,
tokens: &[CppTokenData],
config: &FormatConfig,
qualified_name: &mut dyn FnMut(usize) -> Option<String>,
) -> Vec<FormatLiteral> {
if config.is_off() {
return Vec::new();
}
let mut found = Vec::new();
for (index, token) in tokens.iter().enumerate() {
if token.kind != CppTokenKind::StringLiteral {
continue;
}
let Some(call) = the_call_a_literal_is_in(source, tokens, index) else {
continue;
};
let Some(kind) = the_format_kind_of(&call, config, qualified_name) else {
continue;
};
let Some(text) = source.get(token.range.start_offset..token.range.end_offset()) else {
continue;
};
let mut pieces = Vec::new();
pieces_in(text, kind, &mut pieces);
found.push(FormatLiteral {
range: token.range,
kind,
pieces,
});
}
found
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CallSite {
pub callee: String,
pub qualified: bool,
pub member: bool,
pub argument: usize,
pub first_argument_is_a_literal: bool,
pub callee_offset: usize,
}
fn the_call_a_literal_is_in(
source: &str,
tokens: &[CppTokenData],
index: usize,
) -> Option<CallSite> {
let before = previous_significant(tokens, index)?;
if !matches!(
tokens[before].kind,
CppTokenKind::LeftParen | CppTokenKind::Comma
) {
return None;
}
let after = next_significant(tokens, index)?;
if !matches!(
tokens[after].kind,
CppTokenKind::RightParen | CppTokenKind::Comma
) {
return None;
}
let mut open = None;
let mut depth = 0usize;
let mut at = index;
while at > 0 {
at -= 1;
match tokens[at].kind {
CppTokenKind::RightParen | CppTokenKind::RightBracket | CppTokenKind::RightBrace => {
depth += 1
}
CppTokenKind::LeftBracket | CppTokenKind::LeftBrace if depth == 0 => break,
CppTokenKind::Semicolon if depth == 0 => break,
CppTokenKind::LeftParen => {
if depth == 0 {
open = Some(at);
break;
}
depth -= 1;
}
_ => {}
}
}
let open = open?;
let mut name_end = previous_significant(tokens, open)?;
if tokens[name_end].kind != CppTokenKind::Identifier {
return None;
}
let callee_end = tokens[name_end].range.end_offset();
let mut first = name_end;
let mut qualified = false;
let mut member = false;
while let Some(before_this) = previous_significant(tokens, first) {
match tokens[before_this].kind {
CppTokenKind::Scope => {
let Some(qualifier) = previous_significant(tokens, before_this) else {
first = before_this;
break;
};
if tokens[qualifier].kind != CppTokenKind::Identifier {
first = before_this;
break;
}
qualified = true;
first = qualifier;
name_end = qualifier;
}
CppTokenKind::Dot | CppTokenKind::Arrow => {
member = true;
break;
}
_ => break,
}
}
let callee = source
.get(tokens[first].range.start_offset..callee_end)?
.to_string();
let _ = name_end;
let mut argument = 0usize;
let mut depth = 0usize;
let mut first_argument_is_a_literal = false;
let mut seen_anything = false;
for token in &tokens[open + 1..index] {
if is_layout(token.kind) {
continue;
}
if !seen_anything {
seen_anything = true;
first_argument_is_a_literal = token.kind == CppTokenKind::StringLiteral;
}
match token.kind {
CppTokenKind::LeftParen | CppTokenKind::LeftBracket | CppTokenKind::LeftBrace => {
depth += 1
}
CppTokenKind::RightParen | CppTokenKind::RightBracket | CppTokenKind::RightBrace => {
depth = depth.saturating_sub(1);
}
CppTokenKind::Comma if depth == 0 => argument += 1,
_ => {}
}
}
Some(CallSite {
callee,
qualified,
member,
argument,
first_argument_is_a_literal,
callee_offset: tokens[first].range.start_offset,
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Position {
At(usize),
AtTheFirstArgumentUnlessItIsAStream,
}
const THE_TABLE: &[(&str, FormatKind, Position)] = &[
("format", FormatKind::Std, Position::At(0)),
("format_to", FormatKind::Std, Position::At(1)),
("format_to_n", FormatKind::Std, Position::At(2)),
("formatted_size", FormatKind::Std, Position::At(0)),
("vformat", FormatKind::Std, Position::At(0)),
("vformat_to", FormatKind::Std, Position::At(1)),
(
"print",
FormatKind::Std,
Position::AtTheFirstArgumentUnlessItIsAStream,
),
(
"println",
FormatKind::Std,
Position::AtTheFirstArgumentUnlessItIsAStream,
),
(
"vprint",
FormatKind::Std,
Position::AtTheFirstArgumentUnlessItIsAStream,
),
(
"vprintln",
FormatKind::Std,
Position::AtTheFirstArgumentUnlessItIsAStream,
),
("printf", FormatKind::Printf, Position::At(0)),
("fprintf", FormatKind::Printf, Position::At(1)),
("sprintf", FormatKind::Printf, Position::At(1)),
("snprintf", FormatKind::Printf, Position::At(2)),
("vprintf", FormatKind::Printf, Position::At(0)),
("vfprintf", FormatKind::Printf, Position::At(1)),
("vsprintf", FormatKind::Printf, Position::At(1)),
("vsnprintf", FormatKind::Printf, Position::At(2)),
("dprintf", FormatKind::Printf, Position::At(1)),
("vdprintf", FormatKind::Printf, Position::At(1)),
("asprintf", FormatKind::Printf, Position::At(1)),
("vasprintf", FormatKind::Printf, Position::At(1)),
("syslog", FormatKind::Printf, Position::At(1)),
("vsyslog", FormatKind::Printf, Position::At(2)),
("printf_s", FormatKind::Printf, Position::At(0)),
("fprintf_s", FormatKind::Printf, Position::At(1)),
("sprintf_s", FormatKind::Printf, Position::At(2)),
("snprintf_s", FormatKind::Printf, Position::At(2)),
("vsprintf_s", FormatKind::Printf, Position::At(2)),
("vsnprintf_s", FormatKind::Printf, Position::At(2)),
("wprintf", FormatKind::Printf, Position::At(0)),
("fwprintf", FormatKind::Printf, Position::At(1)),
("vwprintf", FormatKind::Printf, Position::At(0)),
("vfwprintf", FormatKind::Printf, Position::At(1)),
("scanf", FormatKind::Scanf, Position::At(0)),
("fscanf", FormatKind::Scanf, Position::At(1)),
("sscanf", FormatKind::Scanf, Position::At(1)),
("vscanf", FormatKind::Scanf, Position::At(0)),
("vfscanf", FormatKind::Scanf, Position::At(1)),
("vsscanf", FormatKind::Scanf, Position::At(1)),
("scanf_s", FormatKind::Scanf, Position::At(0)),
("fscanf_s", FormatKind::Scanf, Position::At(1)),
("sscanf_s", FormatKind::Scanf, Position::At(1)),
("wscanf", FormatKind::Scanf, Position::At(0)),
("fwscanf", FormatKind::Scanf, Position::At(1)),
("swscanf", FormatKind::Scanf, Position::At(1)),
];
fn the_format_kind_of(
call: &CallSite,
config: &FormatConfig,
qualified_name: &mut dyn FnMut(usize) -> Option<String>,
) -> Option<FormatKind> {
let written = call.callee.strip_prefix("::").unwrap_or(&call.callee);
let (scope, bare) = match written.rfind("::") {
Some(at) => (&written[..at], &written[at + 2..]),
None => ("", written),
};
let mut resolved: Option<Option<String>> = None;
let mut resolved_name = |ask: &mut dyn FnMut(usize) -> Option<String>| -> Option<String> {
if resolved.is_none() {
resolved = Some(ask(call.callee_offset));
}
resolved.clone().flatten()
};
let mine = config.functions.iter().find(|entry| {
entry.name == written
|| (!call.qualified
&& resolved_name(qualified_name).is_some_and(|name| name == entry.name))
});
if let Some(entry) = mine
&& position_matches(Position::At(entry.argument), call)
{
return Some(entry.syntax);
}
let &(_, kind, position) = THE_TABLE.iter().find(|(name, _, _)| *name == bare)?;
let position = match (is_fmt(scope), bare) {
(true, "sprintf") => Position::At(0),
_ => position,
};
match kind {
FormatKind::Std => {
if !scope.is_empty() && scope != "std" && !is_fmt(scope) {
return None;
}
if scope.is_empty()
&& !resolved_name(qualified_name).is_some_and(|name| {
the_scope_of(&name).is_some_and(|s| s == "std" || is_fmt(s))
})
{
return None;
}
if !config.std_format {
return None;
}
}
FormatKind::Printf => {
if !scope.is_empty() && scope != "std" && !is_fmt(scope) {
return None;
}
if !config.printf {
return None;
}
}
FormatKind::Scanf => {
if !scope.is_empty() && scope != "std" && !is_fmt(scope) {
return None;
}
if !config.scanf {
return None;
}
}
}
position_matches(position, call).then_some(kind)
}
fn is_fmt(scope: &str) -> bool {
scope == "fmt"
|| scope.strip_prefix("fmt::v").is_some_and(|version| {
!version.is_empty() && version.bytes().all(|b| b.is_ascii_digit())
})
}
fn the_scope_of(qualified: &str) -> Option<&str> {
qualified.rfind("::").map(|at| &qualified[..at])
}
fn position_matches(position: Position, call: &CallSite) -> bool {
match position {
Position::At(at) => call.argument == at,
Position::AtTheFirstArgumentUnlessItIsAStream => {
call.argument == 0 || (call.argument == 1 && !call.first_argument_is_a_literal)
}
}
}
fn is_layout(kind: CppTokenKind) -> bool {
matches!(
kind,
CppTokenKind::Whitespace
| CppTokenKind::Newline
| CppTokenKind::LineContinuation
| CppTokenKind::LineComment
| CppTokenKind::BlockComment
| CppTokenKind::DocTrivia
| CppTokenKind::Eof
| CppTokenKind::None
)
}
fn previous_significant(tokens: &[CppTokenData], index: usize) -> Option<usize> {
let mut at = index;
while at > 0 {
at -= 1;
if !is_layout(tokens[at].kind) {
return Some(at);
}
}
None
}
fn next_significant(tokens: &[CppTokenData], index: usize) -> Option<usize> {
let mut at = index + 1;
while at < tokens.len() {
if !is_layout(tokens[at].kind) {
return Some(at);
}
at += 1;
}
None
}