use std::path::{Path, PathBuf};
use cpp_parser::{CppTokenData, CppTokenKind, LexerConfig, SourceRange};
use crate::macros::MacroDef;
use crate::token::Token;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ConditionFlavour {
Expression,
Defined,
NotDefined,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Event {
If {
tokens: Vec<Token>,
flavour: ConditionFlavour,
tests: Vec<String>,
range: SourceRange,
},
Elif {
tokens: Vec<Token>,
flavour: ConditionFlavour,
tests: Vec<String>,
range: SourceRange,
},
Else {
range: SourceRange,
},
Endif {
range: SourceRange,
},
Define {
definition: MacroDef,
},
Undef {
name: String,
range: SourceRange,
},
Include {
spelling: String,
angled: bool,
range: SourceRange,
},
Other {
spelling: String,
range: SourceRange,
},
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Surface {
pub path: PathBuf,
pub events: Vec<Event>,
pub tokens: usize,
}
impl Surface {
pub fn tests(&self) -> Vec<String> {
let mut names: Vec<String> = Vec::new();
for event in &self.events {
let tested = match event {
Event::If { tests, .. } | Event::Elif { tests, .. } => tests,
_ => continue,
};
for name in tested {
if !names.contains(name) {
names.push(name.clone());
}
}
}
names.sort();
names
}
pub fn exports(&self) -> Vec<&str> {
self.events
.iter()
.filter_map(|event| match event {
Event::Define { definition } => Some(definition.name.as_ref()),
_ => None,
})
.collect()
}
pub fn undefinitions(&self) -> Vec<&str> {
self.events
.iter()
.filter_map(|event| match event {
Event::Undef { name, .. } => Some(name.as_str()),
_ => None,
})
.collect()
}
pub fn includes(&self) -> Vec<(&str, bool)> {
self.events
.iter()
.filter_map(|event| match event {
Event::Include {
spelling, angled, ..
} => Some((spelling.as_str(), *angled)),
_ => None,
})
.collect()
}
pub fn conditionals(&self) -> usize {
self.events
.iter()
.filter(|event| matches!(event, Event::If { .. } | Event::Elif { .. }))
.count()
}
pub fn signature(&self) -> u64 {
let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
for event in &self.events {
let (tag, text) = match event {
Event::If { tokens, .. } => (1u8, spellings(tokens)),
Event::Elif { tokens, .. } => (2, spellings(tokens)),
Event::Else { .. } => (3, String::new()),
Event::Endif { .. } => (4, String::new()),
Event::Define { definition } => (
5,
format!(
"{}|{}|{}",
definition.name,
definition.is_function_like(),
spellings(&definition.body.tokens)
),
),
Event::Undef { name, .. } => (6, name.clone()),
Event::Include { spelling, .. } => (7, spelling.clone()),
Event::Other { spelling, .. } => (8, spelling.clone()),
};
for byte in text.as_bytes().iter().chain(std::iter::once(&tag)) {
hash ^= u64::from(*byte);
hash = hash.wrapping_mul(0x100_0000_01b3);
}
}
hash
}
}
fn spellings(tokens: &[Token]) -> String {
let mut out = String::new();
for token in tokens {
if crate::token::is_trivia(token.kind) {
continue;
}
out.push_str(&token.text);
out.push(' ');
}
out
}
pub fn surface_of(path: &Path, text: &str) -> Surface {
let (tokens, _) = cpp_parser::lex(text, &LexerConfig::default());
let mut surface = Surface {
path: path.to_path_buf(),
events: Vec::new(),
tokens: tokens.len(),
};
let mut at = 0usize;
while at < tokens.len() {
if tokens[at].kind != CppTokenKind::Hash {
at += 1;
continue;
}
let mut end = at + 1;
while end < tokens.len() && tokens[end].kind != CppTokenKind::Newline {
end += 1;
}
let code: Vec<&CppTokenData> = tokens[at..end]
.iter()
.filter(|token| !crate::token::is_trivia(token.kind))
.collect();
let word = code.get(1).map(|token| spelling(text, token)).unwrap_or("");
let range = tokens[at].range;
match word {
"define" => {
let from_the_name: Vec<Token> = tokens[at + 2..end]
.iter()
.map(|token| Token::new(token.kind, spelling(text, token), token.range))
.collect();
if let Some(definition) =
crate::preprocess::macros::parse_define(&from_the_name, range)
{
surface.events.push(Event::Define { definition });
}
}
"undef" => {
if let Some(name_token) = code.get(2) {
surface.events.push(Event::Undef {
name: spelling(text, name_token).to_string(),
range: name_token.range,
});
}
}
"include" | "include_next" | "import" => {
let body = body_of(text, &code[2.min(code.len())..]);
surface.events.push(Event::Include {
spelling: body.clone(),
angled: body.starts_with('<'),
range: code.get(2).map(|token| token.range).unwrap_or(range),
});
}
"if" | "ifdef" | "ifndef" | "elif" => {
let condition: Vec<Token> = code
.iter()
.skip(2)
.map(|token| Token::new(token.kind, spelling(text, token), token.range))
.collect();
let tests = names_in(&condition);
let flavour = match word {
"ifdef" => ConditionFlavour::Defined,
"ifndef" => ConditionFlavour::NotDefined,
_ => ConditionFlavour::Expression,
};
surface.events.push(if word == "elif" {
Event::Elif {
tokens: condition,
flavour,
tests,
range,
}
} else {
Event::If {
tokens: condition,
flavour,
tests,
range,
}
});
}
"else" => surface.events.push(Event::Else { range }),
"endif" => surface.events.push(Event::Endif { range }),
_ => surface.events.push(Event::Other {
spelling: word.to_string(),
range,
}),
}
at = if end < tokens.len() {
end + 1
} else {
tokens.len()
};
}
surface
}
fn spelling<'a>(text: &'a str, token: &CppTokenData) -> &'a str {
let start = token.range.start_offset;
text.get(start..start + token.range.length).unwrap_or("")
}
fn body_of(text: &str, tokens: &[&CppTokenData]) -> String {
let Some(first) = tokens.first() else {
return String::new();
};
let start = first.range.start_offset;
let last = tokens.last().unwrap_or(first);
let end = last.range.start_offset + last.range.length;
text.get(start..end).unwrap_or("").trim().to_string()
}
pub fn names_in(tokens: &[Token]) -> Vec<String> {
let mut names: Vec<String> = Vec::new();
for token in tokens {
if token.kind != CppTokenKind::Identifier {
continue;
}
let written = token.text.as_ref();
if written == "defined" || names.iter().any(|held| held == written) {
continue;
}
names.push(written.to_string());
}
names.sort();
names
}
#[cfg(test)]
mod tests {
use super::*;
fn scanned(text: &str) -> Surface {
surface_of(Path::new("/p/a.h"), text)
}
#[test]
fn directives_keep_the_order_they_were_written_in() {
let surface = scanned("#define A 1\n#undef A\n#define B 2\n");
assert_eq!(surface.exports(), vec!["A", "B"]);
assert_eq!(surface.undefinitions(), vec!["A"]);
assert!(
matches!(&surface.events[1], Event::Undef { name, .. } if name == "A"),
"the #undef is an event of its own, between the two defines: {:?}",
surface.events
);
}
#[test]
fn a_function_like_macro_is_told_from_an_object_like_one() {
let surface = scanned("#define F(x) ((x) + 1)\n#define G (1)\n");
let defined: Vec<&MacroDef> = surface
.events
.iter()
.filter_map(|event| match event {
Event::Define { definition } => Some(definition),
_ => None,
})
.collect();
assert_eq!(defined.len(), 2, "{:?}", surface.events);
assert!(defined[0].is_function_like(), "F(x) takes an argument");
assert!(
!defined[1].is_function_like(),
"a space before the parenthesis makes G object-like"
);
}
#[test]
fn the_tests_are_the_names_a_conditional_reads() {
let surface = scanned(
"#if defined(_WIN32) && _ITERATOR_DEBUG_LEVEL > 0\nint x;\n#endif\n\
#ifdef GUARD\n#endif\n\
#ifndef __cplusplus\n#endif\n",
);
assert_eq!(
surface.tests(),
vec![
"GUARD".to_string(),
"_ITERATOR_DEBUG_LEVEL".to_string(),
"_WIN32".to_string(),
"__cplusplus".to_string(),
],
"every name a condition asks about, and no operator"
);
assert_eq!(surface.conditionals(), 3);
}
#[test]
fn a_file_that_tests_nothing_is_environment_insensitive() {
let surface = scanned("#define A 1\n#include <vector>\n");
assert!(surface.tests().is_empty());
assert_eq!(surface.includes(), vec![("<vector>", true)]);
assert_eq!(surface.exports(), vec!["A"]);
}
#[test]
fn includes_are_kept_with_their_form() {
let surface = scanned("#include <vector>\n#include \"local.h\"\n");
let includes = surface.includes();
assert_eq!(includes.len(), 2, "{includes:?}");
assert_eq!(includes[0], ("<vector>", true));
assert_eq!(includes[1], ("\"local.h\"", false));
}
#[test]
fn a_hash_that_is_not_a_directive_is_not_an_event() {
let surface = scanned("const char* s = \"#define X\";\n// #define Y\n/* #define Z */\n");
assert!(surface.events.is_empty(), "{:?}", surface.events);
}
#[test]
fn the_exports_are_the_macro_facts_a_parse_reports() {
let text = "#define A 1\n#define F(x) ((x) + 1)\nint x;\n#undef A\n#define B\n";
let surface = surface_of(Path::new("/p/a.h"), text);
let mut from_surface: Vec<&str> = surface.exports();
from_surface.sort();
from_surface.dedup();
let summary =
crate::index::summarize(Path::new("/p/a.h"), text, crate::SummaryKey::new(0, 0));
let mut from_parse: Vec<&str> = summary
.macros
.iter()
.filter(|fact| fact.kind.is_definition())
.map(|fact| fact.name.as_str())
.collect();
from_parse.sort();
from_parse.dedup();
assert_eq!(from_surface, from_parse, "the same names, by two readings");
}
#[test]
fn a_body_edit_does_not_move_the_signature_and_a_define_does() {
let before = scanned("#define A 1\nstruct S { int x; };\n");
let body_changed = scanned("#define A 1\nstruct S { int x; int y; };\n");
assert_eq!(
before.signature(),
body_changed.signature(),
"a declaration in the file's body is not an event"
);
let macro_changed = scanned("#define A 2\nstruct S { int x; };\n");
assert_ne!(
before.signature(),
macro_changed.signature(),
"a different body for the same macro is a different effect"
);
let include_added = scanned("#define A 1\n#include <vector>\nstruct S { int x; };\n");
assert_ne!(before.signature(), include_added.signature());
}
}