mirror of
https://github.com/colbymchenry/codegraph.git
synced 2026-10-18 13:53:01 +08:00
ctype_lab
1328 lines
43 KiB
Rust
1328 lines
43 KiB
Rust
//! Native port of the cFnPtr synthesizer's EXTRACTION SWEEP (task #5 step 2,
|
||
//! plan §7a.9): raw file text in → collected per-file facts out. The linking
|
||
//! stages, gates, and every registration/dispatch decision stay TS-side; this
|
||
//! module only reproduces, bug-for-bug, what the JS sweep computes per file in
|
||
//! `src/resolution/c-fnptr-synthesizer.ts`:
|
||
//!
|
||
//! • `stripCommentsForRegex(text, 'c')` — the C-style comment/string state
|
||
//! machine (comments blanked to spaces, string interiors skipped, backtick
|
||
//! treated as a multi-line string delimiter — quirks and all);
|
||
//! • the typedef scans (fn-pointer + fn-type forms);
|
||
//! • struct-node field declarations (structural parse; classification stays
|
||
//! TS-side where the complete typedef sets live);
|
||
//! • the survival-filter scans (inline structs, initializers, bare arrays,
|
||
//! alias-shaped object macros, field-assign pairs, dispatch fields, array
|
||
//! dispatch names);
|
||
//! • the raw-text `#include "..."` capture (path resolution stays TS-side —
|
||
//! it needs the filesystem).
|
||
//!
|
||
//! Parity discipline: the JS side runs these as JavaScript REGEXES, so every
|
||
//! scanner here is a hand-rolled byte machine replicating THAT engine's
|
||
//! semantics, not idiomatic Rust regex:
|
||
//! • JS `\w`/`\b` are ASCII (non-ASCII chars are non-word) — byte checks
|
||
//! against `[A-Za-z0-9_]` reproduce them exactly, because UTF-8
|
||
//! continuation bytes are non-ASCII and therefore non-word on both sides.
|
||
//! • JS `\s` is the UNICODE whitespace class (NBSP, U+2000-200A, U+FEFF, …)
|
||
//! — `jsws_len` decodes exactly that set from UTF-8.
|
||
//! • Backtracking is reproduced where it is observable (INIT/ARRAY modifier
|
||
//! and `struct` keyword ambiguity, DISPATCH's greedy segment loop,
|
||
//! optional groups) and elided only where analysis shows no input can
|
||
//! distinguish greedy from backtracked (documented per scanner).
|
||
//! • `lastIndex` advancement (resume after each match, +1 on failure) is
|
||
//! reproduced so overlapping-match selection is identical.
|
||
//!
|
||
//! The stripper blanks per UTF-16 code unit (see `strip_c`), so its output
|
||
//! equals the JS stripper's output EXACTLY as a string — every scanner here
|
||
//! runs over the identical character stream the JS regexes see, and the strip
|
||
//! differential oracle test pins that equality directly. The record-level
|
||
//! differential suite (JS sweep vs this sweep over fixtures and whole repos)
|
||
//! then pins the scanners themselves.
|
||
|
||
/// One struct node's extent, as the TS side reads it from the graph.
|
||
pub struct StructExtent {
|
||
pub id: String,
|
||
pub start_line: u32,
|
||
pub end_line: u32,
|
||
}
|
||
|
||
/// A structurally-parsed struct field — mirror of the TS `RawFieldDecl`
|
||
/// (`name: null` is represented as an empty string; the TS side treats them
|
||
/// identically everywhere).
|
||
pub struct RawField {
|
||
pub name: String,
|
||
pub index: u32,
|
||
pub ptr: bool,
|
||
pub ty: String,
|
||
}
|
||
|
||
pub struct StructFields {
|
||
pub id: String,
|
||
/// False when the body never parsed (no `{`, unbalanced braces, or a
|
||
/// falsy start line) — the TS side then records nothing for this node,
|
||
/// exactly like the JS sweep.
|
||
pub parsed: bool,
|
||
pub fields: Vec<RawField>,
|
||
}
|
||
|
||
/// Everything the sweep collects for one file.
|
||
pub struct FileFacts {
|
||
pub fn_ptr_typedefs: Vec<String>,
|
||
pub fn_type_typedefs: Vec<String>,
|
||
pub structs: Vec<StructFields>,
|
||
pub inline_ptr: bool,
|
||
pub inline_types: Vec<String>,
|
||
pub inline_tags: Vec<String>,
|
||
pub init_tokens: Vec<String>,
|
||
/// `*`-prefixed when the declaration carried the pointer star.
|
||
pub array_elems: Vec<String>,
|
||
pub alias_names: Vec<String>,
|
||
/// `lfield\0rfield`, distinct.
|
||
pub d_pairs: Vec<String>,
|
||
pub dispatch_fields: Vec<String>,
|
||
pub array_dispatch_names: Vec<String>,
|
||
/// Raw `#include "…"` captures, in source order, NOT deduplicated —
|
||
/// extension filtering and path resolution happen TS-side.
|
||
pub includes: Vec<String>,
|
||
}
|
||
|
||
/// Mirror of the TS `C_TYPE_KEYWORDS` set — keep in exact sync.
|
||
const C_TYPE_KEYWORDS: [&[u8]; 17] = [
|
||
b"void", b"int", b"char", b"short", b"long", b"unsigned", b"signed", b"float", b"double",
|
||
b"const", b"struct", b"union", b"enum", b"static", b"volatile", b"register", b"inline",
|
||
];
|
||
|
||
fn is_type_keyword(w: &[u8]) -> bool {
|
||
C_TYPE_KEYWORDS.iter().any(|k| *k == w)
|
||
}
|
||
|
||
const MODIFIERS: [&[u8]; 5] = [b"static", b"const", b"extern", b"register", b"volatile"];
|
||
|
||
#[inline]
|
||
fn is_word(b: u8) -> bool {
|
||
b.is_ascii_alphanumeric() || b == b'_'
|
||
}
|
||
|
||
#[inline]
|
||
fn is_word_at(s: &[u8], i: usize) -> bool {
|
||
i < s.len() && is_word(s[i])
|
||
}
|
||
|
||
/// Byte length of the JS `\s` character starting at `i`, or 0 when `s[i]`
|
||
/// doesn't start one. JS \s = [\t\n\v\f\r -
|
||
///
].
|
||
#[inline]
|
||
fn jsws_len(s: &[u8], i: usize) -> usize {
|
||
let Some(&b0) = s.get(i) else { return 0 };
|
||
match b0 {
|
||
0x09..=0x0D | 0x20 => 1,
|
||
0xC2 if s.get(i + 1) == Some(&0xA0) => 2, // U+00A0
|
||
0xE1 if s.get(i + 1) == Some(&0x9A) && s.get(i + 2) == Some(&0x80) => 3, // U+1680
|
||
0xE2 => match (s.get(i + 1), s.get(i + 2)) {
|
||
(Some(&0x80), Some(&b2)) if (0x80..=0x8A).contains(&b2) => 3, // U+2000-200A
|
||
(Some(&0x80), Some(&0xA8)) => 3, // U+2028
|
||
(Some(&0x80), Some(&0xA9)) => 3, // U+2029
|
||
(Some(&0x80), Some(&0xAF)) => 3, // U+202F
|
||
(Some(&0x81), Some(&0x9F)) => 3, // U+205F
|
||
_ => 0,
|
||
},
|
||
0xE3 if s.get(i + 1) == Some(&0x80) && s.get(i + 2) == Some(&0x80) => 3, // U+3000
|
||
0xEF if s.get(i + 1) == Some(&0xBB) && s.get(i + 2) == Some(&0xBF) => 3, // U+FEFF
|
||
_ => 0,
|
||
}
|
||
}
|
||
|
||
/// Advance past `\s*`.
|
||
#[inline]
|
||
fn skip_jsws(s: &[u8], mut i: usize) -> usize {
|
||
loop {
|
||
let l = jsws_len(s, i);
|
||
if l == 0 {
|
||
return i;
|
||
}
|
||
i += l;
|
||
}
|
||
}
|
||
|
||
/// End of the `\w+` run starting at `i` (caller checks `is_word_at(s, i)`).
|
||
#[inline]
|
||
fn word_end(s: &[u8], mut i: usize) -> usize {
|
||
while i < s.len() && is_word(s[i]) {
|
||
i += 1;
|
||
}
|
||
i
|
||
}
|
||
|
||
/// JS `\b` before position `i` (position 0, or previous byte non-word).
|
||
#[inline]
|
||
fn boundary_before(s: &[u8], i: usize) -> bool {
|
||
i == 0 || !is_word(s[i - 1])
|
||
}
|
||
|
||
fn find_bytes(s: &[u8], needle: &[u8], from: usize) -> Option<usize> {
|
||
if needle.is_empty() || s.len() < needle.len() {
|
||
return None;
|
||
}
|
||
let mut i = from;
|
||
while i + needle.len() <= s.len() {
|
||
// memchr on the first byte keeps this fast on 20KB+ files.
|
||
match s[i..s.len() - needle.len() + 1].iter().position(|&b| b == needle[0]) {
|
||
None => return None,
|
||
Some(off) => {
|
||
i += off;
|
||
if &s[i..i + needle.len()] == needle {
|
||
return Some(i);
|
||
}
|
||
i += 1;
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
fn contains_bytes(s: &[u8], needle: &[u8]) -> bool {
|
||
find_bytes(s, needle, 0).is_some()
|
||
}
|
||
|
||
/// `\bWORD\b` occurrence search from `from`.
|
||
fn find_word(s: &[u8], word: &[u8], mut from: usize) -> Option<usize> {
|
||
loop {
|
||
let t = find_bytes(s, word, from)?;
|
||
if boundary_before(s, t) && !is_word_at(s, t + word.len()) {
|
||
return Some(t);
|
||
}
|
||
from = t + 1;
|
||
}
|
||
}
|
||
|
||
// ---------- stripCommentsForRegex(src, 'c') ----------
|
||
|
||
/// Port of `stripCStyle(src, /*allowSingleQuoteStrings*/ false)`:
|
||
/// `/* */` and `//` comments blanked to spaces (newlines preserved), `"` and
|
||
/// backtick string interiors skipped verbatim (backtick spans lines — the JS
|
||
/// helper treats it as a template literal even for C), `'` NOT special.
|
||
///
|
||
/// Blanking is per UTF-16 CODE UNIT (one space per BMP char, two per astral
|
||
/// char), so the result equals the JS stripper's output EXACTLY as a string —
|
||
/// the scanners downstream see the identical character stream the JS regexes
|
||
/// see, and the strip differential oracle pins byte equality directly.
|
||
/// (Comment boundaries — `/*`, `*/`, `//`, quotes, `\n` — are all ASCII, so
|
||
/// the state machine's byte positions always land on char boundaries.)
|
||
pub fn strip_c(src: &[u8]) -> Vec<u8> {
|
||
let n = src.len();
|
||
let mut out = Vec::with_capacity(n);
|
||
let mut copied = 0usize; // src[..copied] already emitted
|
||
let mut i = 0;
|
||
{
|
||
let mut blank_to = |out: &mut Vec<u8>, start: usize, end: usize| {
|
||
out.extend_from_slice(&src[copied..start]);
|
||
emit_blank(out, &src[start..end]);
|
||
copied = end;
|
||
};
|
||
while i < n {
|
||
let c = src[i];
|
||
let c2 = if i + 1 < n { src[i + 1] } else { 0 };
|
||
if c == b'/' && c2 == b'*' {
|
||
let start = i;
|
||
i += 2;
|
||
while i < n && !(src[i] == b'*' && i + 1 < n && src[i + 1] == b'/') {
|
||
i += 1;
|
||
}
|
||
if i < n {
|
||
i += 2;
|
||
}
|
||
blank_to(&mut out, start, i.min(n));
|
||
continue;
|
||
}
|
||
if c == b'/' && c2 == b'/' {
|
||
let start = i;
|
||
while i < n && src[i] != b'\n' {
|
||
i += 1;
|
||
}
|
||
blank_to(&mut out, start, i);
|
||
continue;
|
||
}
|
||
if c == b'"' || c == b'`' {
|
||
let quote = c;
|
||
i += 1;
|
||
while i < n && src[i] != quote {
|
||
if src[i] == b'\\' && i + 1 < n {
|
||
i += 2;
|
||
continue;
|
||
}
|
||
if quote != b'`' && src[i] == b'\n' {
|
||
break;
|
||
}
|
||
i += 1;
|
||
}
|
||
if i < n && src[i] == quote {
|
||
i += 1;
|
||
}
|
||
continue;
|
||
}
|
||
i += 1;
|
||
}
|
||
}
|
||
out.extend_from_slice(&src[copied..]);
|
||
out
|
||
}
|
||
|
||
/// One space per UTF-16 code unit (`\n` preserved): ASCII and 2-3-byte chars
|
||
/// are one unit, 4-byte (astral) chars are a surrogate pair — two units.
|
||
fn emit_blank(out: &mut Vec<u8>, region: &[u8]) {
|
||
let mut i = 0;
|
||
while i < region.len() {
|
||
let b = region[i];
|
||
if b == b'\n' {
|
||
out.push(b'\n');
|
||
i += 1;
|
||
continue;
|
||
}
|
||
let len = if b < 0x80 {
|
||
1
|
||
} else if b < 0xC0 {
|
||
1 // continuation byte at region start — invalid UTF-8; count singly
|
||
} else if b < 0xE0 {
|
||
2
|
||
} else if b < 0xF0 {
|
||
3
|
||
} else {
|
||
4
|
||
};
|
||
out.push(b' ');
|
||
if len == 4 {
|
||
out.push(b' ');
|
||
}
|
||
i += len.min(region.len() - i);
|
||
}
|
||
}
|
||
|
||
// ---------- shared regex tails ----------
|
||
|
||
/// `\(\s*(?:\w+\s+)*\*\s*(\w+)\s*\)\s*\(` matched at `open` (which must hold
|
||
/// `(`). Returns (name_range, end_after_second_paren). The `(?:\w+\s+)*`
|
||
/// group is greedy without backtracking: giving back an iteration repositions
|
||
/// `\*` onto a word char, which can never match, so greedy ≡ backtracked.
|
||
fn fnptr_paren_tail(s: &[u8], open: usize) -> Option<((usize, usize), usize)> {
|
||
let mut i = skip_jsws(s, open + 1);
|
||
loop {
|
||
if !is_word_at(s, i) {
|
||
break;
|
||
}
|
||
let we = word_end(s, i);
|
||
let wse = skip_jsws(s, we);
|
||
if wse == we {
|
||
break; // \w+ not followed by \s+ — the iteration fails, word not consumed
|
||
}
|
||
i = wse;
|
||
}
|
||
if s.get(i) != Some(&b'*') {
|
||
return None;
|
||
}
|
||
i = skip_jsws(s, i + 1);
|
||
if !is_word_at(s, i) {
|
||
return None;
|
||
}
|
||
let name = (i, word_end(s, i));
|
||
i = skip_jsws(s, name.1);
|
||
if s.get(i) != Some(&b')') {
|
||
return None;
|
||
}
|
||
i = skip_jsws(s, i + 1);
|
||
if s.get(i) != Some(&b'(') {
|
||
return None;
|
||
}
|
||
Some((name, i + 1))
|
||
}
|
||
|
||
/// `\s*\)?\s*\(` at `i` → position after the `(`. The optional `)` needs no
|
||
/// backtracking: retrying without a consumed `)` lands `\(` on that `)`.
|
||
fn close_call_tail(s: &[u8], i: usize) -> Option<usize> {
|
||
let mut j = skip_jsws(s, i);
|
||
if s.get(j) == Some(&b')') {
|
||
j = skip_jsws(s, j + 1);
|
||
}
|
||
if s.get(j) == Some(&b'(') {
|
||
return Some(j + 1);
|
||
}
|
||
None
|
||
}
|
||
|
||
// ---------- scanners ----------
|
||
|
||
/// FNPTR_TYPEDEF_RE: /\btypedef\b[^;{}]*?\(\s*(?:\w+\s+)*\*\s*(\w+)\s*\)\s*\(/g
|
||
fn scan_fnptr_typedefs(s: &[u8], out: &mut Vec<String>) {
|
||
let mut last = 0;
|
||
while let Some(t) = find_word(s, b"typedef", last) {
|
||
let mut j = t + 7;
|
||
let mut matched = None;
|
||
// Lazy [^;{}]*?: try the paren tail at each `(` in order; the class
|
||
// may also expand ACROSS a failed `(` (it admits parens).
|
||
while j < s.len() {
|
||
let ch = s[j];
|
||
if ch == b';' || ch == b'{' || ch == b'}' {
|
||
break;
|
||
}
|
||
if ch == b'(' {
|
||
if let Some((name, end)) = fnptr_paren_tail(s, j) {
|
||
matched = Some((name, end));
|
||
break;
|
||
}
|
||
}
|
||
j += 1;
|
||
}
|
||
match matched {
|
||
Some(((ns, ne), end)) => {
|
||
push_str(out, &s[ns..ne]);
|
||
last = end;
|
||
}
|
||
None => last = t + 1,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// FNTYPE_TYPEDEF_STMT_RE (/\btypedef\b([^;{}]*);/g) + the TS-side guts
|
||
/// checks: skip when guts contains `(*` or `( *`; else the FIRST
|
||
/// /\b(\w+)\s*\(/ capture, filtered through C_TYPE_KEYWORDS.
|
||
fn scan_fntype_typedefs(s: &[u8], out: &mut Vec<String>) {
|
||
let mut last = 0;
|
||
while let Some(t) = find_word(s, b"typedef", last) {
|
||
let mut j = t + 7;
|
||
while j < s.len() && s[j] != b';' && s[j] != b'{' && s[j] != b'}' {
|
||
j += 1;
|
||
}
|
||
if j >= s.len() || s[j] != b';' {
|
||
last = t + 1;
|
||
continue;
|
||
}
|
||
let guts = &s[t + 7..j];
|
||
if !contains_bytes(guts, b"(*") && !contains_bytes(guts, b"( *") {
|
||
// first \b(\w+)\s*\( in guts
|
||
let mut p = 0;
|
||
while p < guts.len() {
|
||
if is_word(guts[p]) && boundary_before(guts, p) {
|
||
let we = word_end(guts, p);
|
||
let k = skip_jsws(guts, we);
|
||
if guts.get(k) == Some(&b'(') {
|
||
let w = &guts[p..we];
|
||
if !is_type_keyword(w) {
|
||
push_str(out, w);
|
||
}
|
||
break;
|
||
}
|
||
p = we;
|
||
} else {
|
||
p += 1;
|
||
}
|
||
}
|
||
}
|
||
last = j + 1;
|
||
}
|
||
}
|
||
|
||
/// INLINE_STRUCT_RE (/\bstruct\s+(\w+)\s*\{/g), sweep flavor: NO cursor jump
|
||
/// (the filter needs a superset of the registration pass's jump-scan), each
|
||
/// valid candidate (balanced braces + the `^\s*(\w+)…` var check) contributes
|
||
/// its tag and a structural field summary.
|
||
struct InlineScan {
|
||
ptr: bool,
|
||
types: Vec<String>,
|
||
tags: Vec<String>,
|
||
}
|
||
|
||
fn scan_inline_structs(s: &[u8]) -> InlineScan {
|
||
let mut out = InlineScan { ptr: false, types: Vec::new(), tags: Vec::new() };
|
||
let mut last = 0;
|
||
loop {
|
||
let next_struct = find_word(s, b"struct", last);
|
||
let next_union = find_word(s, b"union", last);
|
||
let Some((t, keyword_len)) = (match (next_struct, next_union) {
|
||
(Some(st), Some(un)) if st < un => Some((st, 6)),
|
||
(Some(_), Some(un)) => Some((un, 5)),
|
||
(Some(st), None) => Some((st, 6)),
|
||
(None, Some(un)) => Some((un, 5)),
|
||
(None, None) => None,
|
||
}) else {
|
||
break;
|
||
};
|
||
let after_kw = t + keyword_len;
|
||
let ws = skip_jsws(s, after_kw);
|
||
if ws == after_kw || !is_word_at(s, ws) {
|
||
last = t + 1;
|
||
continue;
|
||
}
|
||
let te = word_end(s, ws);
|
||
let open = skip_jsws(s, te);
|
||
if s.get(open) != Some(&b'{') {
|
||
last = t + 1;
|
||
continue;
|
||
}
|
||
last = open + 1; // lastIndex = end of match (after `{`)
|
||
let Some(close) = match_brace(s, open) else { continue };
|
||
// vm: /^\s*(\w+)…/ on the text after `}` — only vm[1] matters here.
|
||
let v = skip_jsws(s, close + 1);
|
||
if !is_word_at(s, v) {
|
||
continue;
|
||
}
|
||
push_str(&mut out.tags, &s[ws..te]);
|
||
for f in parse_struct_fields_raw(&s[open + 1..close]) {
|
||
if f.name.is_empty() {
|
||
continue;
|
||
}
|
||
if f.ptr {
|
||
out.ptr = true;
|
||
} else if !f.ty.is_empty() {
|
||
out.types.push(f.ty);
|
||
}
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// matchBrace: index of the `}` matching the `{` at `open`, or None.
|
||
fn match_brace(s: &[u8], open: usize) -> Option<usize> {
|
||
let mut depth = 0i64;
|
||
let mut i = open;
|
||
while i < s.len() {
|
||
match s[i] {
|
||
b'{' => depth += 1,
|
||
b'}' => {
|
||
depth -= 1;
|
||
if depth == 0 {
|
||
return Some(i);
|
||
}
|
||
}
|
||
_ => {}
|
||
}
|
||
i += 1;
|
||
}
|
||
None
|
||
}
|
||
|
||
/// The `(?:(?:static|const|extern|register|volatile)\s+)*` modifier loop:
|
||
/// greedy positions after 0..=k iterations, for the k-descending backtrack the
|
||
/// INIT/ARRAY skeletons need. No two alternatives share a prefix, so at most
|
||
/// one literal can match at a position; an alternative that matches without
|
||
/// trailing `\s+` ends the loop (JS: iteration fails, no other alt can fire).
|
||
fn modifier_positions(s: &[u8], start: usize) -> Vec<usize> {
|
||
let mut stack = vec![start];
|
||
loop {
|
||
let cur = *stack.last().unwrap();
|
||
let mut advanced = None;
|
||
for m in MODIFIERS {
|
||
if s.len() >= cur + m.len() && &s[cur..cur + m.len()] == m {
|
||
let e = cur + m.len();
|
||
let w = skip_jsws(s, e);
|
||
if w > e {
|
||
advanced = Some(w);
|
||
}
|
||
break; // exactly one alternative can literal-match here
|
||
}
|
||
}
|
||
match advanced {
|
||
Some(w) => stack.push(w),
|
||
None => return stack,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// `\[[^\]]*\]` at `i` (the INIT/ARRAY declarator form — the class admits
|
||
/// newlines): position after the FIRST `]`, or None.
|
||
fn bracket_span(s: &[u8], i: usize) -> Option<usize> {
|
||
if s.get(i) != Some(&b'[') {
|
||
return None;
|
||
}
|
||
let mut j = i + 1;
|
||
while j < s.len() && s[j] != b']' {
|
||
j += 1;
|
||
}
|
||
if j < s.len() {
|
||
Some(j + 1)
|
||
} else {
|
||
None
|
||
}
|
||
}
|
||
|
||
/// Anchor-skeleton driver shared by INIT_RE and ARRAY_TABLE_RE: both match
|
||
/// `(?:^|[;{}])` then a body, and resume from the end of each match. `body`
|
||
/// returns (token, match_end) when the body matches at the position after the
|
||
/// anchor.
|
||
fn scan_anchored<F>(s: &[u8], mut body: F, out: &mut Vec<String>)
|
||
where
|
||
F: FnMut(&[u8], usize) -> Option<(String, usize)>,
|
||
{
|
||
let mut last = 0usize;
|
||
// The `^` branch consumes nothing and only exists at position 0.
|
||
if last == 0 {
|
||
if let Some((tok, end)) = body(s, 0) {
|
||
out.push(tok);
|
||
last = end;
|
||
}
|
||
}
|
||
let mut p = last;
|
||
while p < s.len() {
|
||
let ch = s[p];
|
||
if ch == b';' || ch == b'{' || ch == b'}' {
|
||
if let Some((tok, end)) = body(s, p + 1) {
|
||
out.push(tok);
|
||
p = end;
|
||
continue;
|
||
}
|
||
}
|
||
p += 1;
|
||
}
|
||
}
|
||
|
||
/// INIT_RE body after the anchor:
|
||
/// `\s*(?:MOD\s+)*(?:struct\s+)?(\w+)\s+(\w+)\s*(\[[^\]]*\])?\s*=\s*\{`
|
||
/// Backtracks: modifier count (desc), `struct` with/without, bracket
|
||
/// with/without — exactly the observable dimensions of the JS engine.
|
||
fn init_body(s: &[u8], p: usize) -> Option<(String, usize)> {
|
||
let i = skip_jsws(s, p);
|
||
let mods = modifier_positions(s, i);
|
||
for &pos in mods.iter().rev() {
|
||
for keyword in [Some(b"struct".as_slice()), Some(b"union".as_slice()), None] {
|
||
let q = if let Some(keyword) = keyword {
|
||
if s.len() >= pos + keyword.len() && &s[pos..pos + keyword.len()] == keyword {
|
||
let e = pos + keyword.len();
|
||
let w = skip_jsws(s, e);
|
||
if w == e {
|
||
continue;
|
||
}
|
||
w
|
||
} else {
|
||
continue;
|
||
}
|
||
} else {
|
||
pos
|
||
};
|
||
if !is_word_at(s, q) {
|
||
continue;
|
||
}
|
||
let te = word_end(s, q);
|
||
let w = skip_jsws(s, te);
|
||
if w == te {
|
||
continue; // \s+ needs ≥1
|
||
}
|
||
if !is_word_at(s, w) {
|
||
continue;
|
||
}
|
||
let ne = word_end(s, w);
|
||
let r = skip_jsws(s, ne);
|
||
for with_bracket in [true, false] {
|
||
let r2 = if with_bracket {
|
||
match bracket_span(s, r) {
|
||
Some(e) => e,
|
||
None => continue,
|
||
}
|
||
} else {
|
||
r
|
||
};
|
||
let r3 = skip_jsws(s, r2);
|
||
if s.get(r3) != Some(&b'=') {
|
||
continue;
|
||
}
|
||
let r4 = skip_jsws(s, r3 + 1);
|
||
if s.get(r4) != Some(&b'{') {
|
||
continue;
|
||
}
|
||
return Some((bytes_to_string(&s[q..te]), r4 + 1));
|
||
}
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
/// ARRAY_TABLE_RE body after the anchor:
|
||
/// `\s*(?:MOD\s+)*(\w+)\s+(\*\s*)?(\w+)\s*\[[^\]]*\]\s*=\s*\{`
|
||
/// Token is `*`-prefixed when the star declarator is present.
|
||
fn array_table_body(s: &[u8], p: usize) -> Option<(String, usize)> {
|
||
let i = skip_jsws(s, p);
|
||
let mods = modifier_positions(s, i);
|
||
for &pos in mods.iter().rev() {
|
||
if !is_word_at(s, pos) {
|
||
continue;
|
||
}
|
||
let te = word_end(s, pos);
|
||
let w = skip_jsws(s, te);
|
||
if w == te {
|
||
continue;
|
||
}
|
||
for with_star in [true, false] {
|
||
let q = if with_star {
|
||
if s.get(w) == Some(&b'*') {
|
||
skip_jsws(s, w + 1)
|
||
} else {
|
||
continue;
|
||
}
|
||
} else {
|
||
w
|
||
};
|
||
if !is_word_at(s, q) {
|
||
continue;
|
||
}
|
||
let ne = word_end(s, q);
|
||
let r = skip_jsws(s, ne);
|
||
let Some(r2) = bracket_span(s, r) else { continue };
|
||
let r3 = skip_jsws(s, r2);
|
||
if s.get(r3) != Some(&b'=') {
|
||
continue;
|
||
}
|
||
let r4 = skip_jsws(s, r3 + 1);
|
||
if s.get(r4) != Some(&b'{') {
|
||
continue;
|
||
}
|
||
let mut tok = String::new();
|
||
if with_star {
|
||
tok.push('*');
|
||
}
|
||
tok.push_str(&bytes_to_string(&s[pos..te]));
|
||
return Some((tok, r4 + 1));
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
/// OBJ_ALIAS_RE over the continuation-joined text:
|
||
/// /^[ \t]*#[ \t]*define[ \t]+(\w+)[ \t]+(?:struct[ \t]+)*[A-Za-z_]\w*[ \t\r]*$/gm
|
||
fn scan_alias_names(stripped: &[u8], out: &mut Vec<String>) {
|
||
// joined = stripped.replace(/\\\r?\n/g, ' ')
|
||
let mut joined = Vec::with_capacity(stripped.len());
|
||
let mut i = 0;
|
||
while i < stripped.len() {
|
||
let b = stripped[i];
|
||
if b == b'\\' {
|
||
if stripped.get(i + 1) == Some(&b'\n') {
|
||
joined.push(b' ');
|
||
i += 2;
|
||
continue;
|
||
}
|
||
if stripped.get(i + 1) == Some(&b'\r') && stripped.get(i + 2) == Some(&b'\n') {
|
||
joined.push(b' ');
|
||
i += 3;
|
||
continue;
|
||
}
|
||
}
|
||
joined.push(b);
|
||
i += 1;
|
||
}
|
||
for line in joined.split(|&b| b == b'\n') {
|
||
if let Some(name) = alias_line(line) {
|
||
push_str(out, name);
|
||
}
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn skip_sp_tab(line: &[u8], mut i: usize) -> usize {
|
||
while i < line.len() && (line[i] == b' ' || line[i] == b'\t') {
|
||
i += 1;
|
||
}
|
||
i
|
||
}
|
||
|
||
fn alias_line(line: &[u8]) -> Option<&[u8]> {
|
||
let mut i = skip_sp_tab(line, 0);
|
||
if line.get(i) != Some(&b'#') {
|
||
return None;
|
||
}
|
||
i = skip_sp_tab(line, i + 1);
|
||
if line.len() < i + 6 || &line[i..i + 6] != b"define" {
|
||
return None;
|
||
}
|
||
i += 6;
|
||
let w = skip_sp_tab(line, i);
|
||
if w == i || !is_word_at(line, w) {
|
||
return None;
|
||
}
|
||
let name_end = word_end(line, w);
|
||
let name = &line[w..name_end];
|
||
let v0 = skip_sp_tab(line, name_end);
|
||
if v0 == name_end {
|
||
return None; // [ \t]+ before the value
|
||
}
|
||
// (?:(?:struct|union)[ \t]+)* greedy, k-descending on value failure.
|
||
let mut stack = vec![v0];
|
||
loop {
|
||
let cur = *stack.last().unwrap();
|
||
let keyword_len = if line.len() >= cur + 6 && &line[cur..cur + 6] == b"struct" {
|
||
Some(6)
|
||
} else if line.len() >= cur + 5 && &line[cur..cur + 5] == b"union" {
|
||
Some(5)
|
||
} else {
|
||
None
|
||
};
|
||
if let Some(keyword_len) = keyword_len {
|
||
let e = cur + keyword_len;
|
||
let w2 = skip_sp_tab(line, e);
|
||
if w2 > e {
|
||
stack.push(w2);
|
||
continue;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
for &vp in stack.iter().rev() {
|
||
let Some(&b0) = line.get(vp) else { continue };
|
||
if !(b0.is_ascii_alphabetic() || b0 == b'_') {
|
||
continue; // value must start [A-Za-z_]
|
||
}
|
||
let ve = word_end(line, vp);
|
||
// [ \t\r]*$
|
||
let mut t = ve;
|
||
while t < line.len() && (line[t] == b' ' || line[t] == b'\t' || line[t] == b'\r') {
|
||
t += 1;
|
||
}
|
||
if t == line.len() {
|
||
return Some(name);
|
||
}
|
||
}
|
||
None
|
||
}
|
||
|
||
/// FIELD_ASSIGN_RE: /(\w+)\s*(?:->|\.)\s*(\w+)\s*=\s*(\w+)\s*(?:->|\.)\s*(\w+)/g
|
||
/// Pairs collected as `lfield\0rfield`. Every byte position is a candidate
|
||
/// start (JS advances one unit on failure — suffix starts included); matches
|
||
/// resume at their end.
|
||
fn scan_field_assign(s: &[u8], out: &mut Vec<String>) {
|
||
let mut pos = 0usize;
|
||
while pos < s.len() {
|
||
if !is_word(s[pos]) {
|
||
pos += 1;
|
||
continue;
|
||
}
|
||
match field_assign_at(s, pos) {
|
||
Some((lf, rf, end)) => {
|
||
let mut pair = bytes_to_string(&s[lf.0..lf.1]);
|
||
pair.push('\0');
|
||
pair.push_str(&bytes_to_string(&s[rf.0..rf.1]));
|
||
out.push(pair);
|
||
pos = end;
|
||
}
|
||
None => pos += 1,
|
||
}
|
||
}
|
||
}
|
||
|
||
#[inline]
|
||
fn arrow_at(s: &[u8], i: usize) -> Option<usize> {
|
||
if s.get(i) == Some(&b'-') && s.get(i + 1) == Some(&b'>') {
|
||
Some(i + 2)
|
||
} else if s.get(i) == Some(&b'.') {
|
||
Some(i + 1)
|
||
} else {
|
||
None
|
||
}
|
||
}
|
||
|
||
type Range = (usize, usize);
|
||
|
||
fn field_assign_at(s: &[u8], p: usize) -> Option<(Range, Range, usize)> {
|
||
let w1 = word_end(s, p);
|
||
let a1 = arrow_at(s, skip_jsws(s, w1))?;
|
||
let f1s = skip_jsws(s, a1);
|
||
if !is_word_at(s, f1s) {
|
||
return None;
|
||
}
|
||
let f1e = word_end(s, f1s);
|
||
let eq = skip_jsws(s, f1e);
|
||
if s.get(eq) != Some(&b'=') {
|
||
return None;
|
||
}
|
||
let r1s = skip_jsws(s, eq + 1);
|
||
if !is_word_at(s, r1s) {
|
||
return None;
|
||
}
|
||
let r1e = word_end(s, r1s);
|
||
let a2 = arrow_at(s, skip_jsws(s, r1e))?;
|
||
let f2s = skip_jsws(s, a2);
|
||
if !is_word_at(s, f2s) {
|
||
return None;
|
||
}
|
||
let f2e = word_end(s, f2s);
|
||
Some(((f1s, f1e), (f2s, f2e), f2e))
|
||
}
|
||
|
||
/// DISPATCH_RE: /((?:\w+(?:\s*\[[^\][]*\])?\s*(?:->|\.)\s*)+)(\w+)\s*\)?\s*\(/g
|
||
/// The `+` loop is consumed greedily, then the field tail is tried at each
|
||
/// segment count k descending — the JS engine's observable backtracking. The
|
||
/// per-segment optional subscript needs no cross-product: the with/without
|
||
/// parses diverge at the arrow and at most one can complete a segment.
|
||
fn scan_dispatch(s: &[u8], out: &mut Vec<String>) {
|
||
let mut pos = 0usize;
|
||
while pos < s.len() {
|
||
if !is_word(s[pos]) {
|
||
pos += 1;
|
||
continue;
|
||
}
|
||
// Greedy segment loop.
|
||
let mut seg_ends: Vec<usize> = Vec::new();
|
||
let mut cur = pos;
|
||
while is_word_at(s, cur) {
|
||
let we = word_end(s, cur);
|
||
let with_sub = subscript_span(s, skip_jsws(s, we)).and_then(|e| arrow_tail(s, e));
|
||
let seg = with_sub.or_else(|| arrow_tail(s, we));
|
||
match seg {
|
||
Some(e) => {
|
||
seg_ends.push(e);
|
||
cur = e;
|
||
}
|
||
None => break,
|
||
}
|
||
}
|
||
let mut matched = None;
|
||
for k in (1..=seg_ends.len()).rev() {
|
||
let fpos = seg_ends[k - 1];
|
||
if !is_word_at(s, fpos) {
|
||
continue;
|
||
}
|
||
let fe = word_end(s, fpos);
|
||
if let Some(end) = close_call_tail(s, fe) {
|
||
matched = Some(((fpos, fe), end));
|
||
break;
|
||
}
|
||
}
|
||
match matched {
|
||
Some(((fs_, fe), end)) => {
|
||
push_str(out, &s[fs_..fe]);
|
||
pos = end;
|
||
}
|
||
None => pos += 1,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// `\[[^\][]*\]` at `i` (the DISPATCH subscript form — no nested brackets):
|
||
/// position after `]`, or None.
|
||
fn subscript_span(s: &[u8], i: usize) -> Option<usize> {
|
||
if s.get(i) != Some(&b'[') {
|
||
return None;
|
||
}
|
||
let mut j = i + 1;
|
||
while j < s.len() && s[j] != b']' && s[j] != b'[' {
|
||
j += 1;
|
||
}
|
||
if j < s.len() && s[j] == b']' {
|
||
Some(j + 1)
|
||
} else {
|
||
None
|
||
}
|
||
}
|
||
|
||
/// `\s*(?:->|\.)\s*` at `i` → position after.
|
||
#[inline]
|
||
fn arrow_tail(s: &[u8], i: usize) -> Option<usize> {
|
||
let a = arrow_at(s, skip_jsws(s, i))?;
|
||
Some(skip_jsws(s, a))
|
||
}
|
||
|
||
/// ARRAY_DISPATCH_RE: /(?:\(\s*\*\s*)?\b(\w+)\s*\[[^\][]*\]\s*\)?\s*\(/g
|
||
fn scan_array_dispatch(s: &[u8], out: &mut Vec<String>) {
|
||
let mut pos = 0usize;
|
||
while pos < s.len() {
|
||
let b = s[pos];
|
||
if b != b'(' && !(is_word(b) && boundary_before(s, pos)) {
|
||
pos += 1;
|
||
continue;
|
||
}
|
||
let name_start = if b == b'(' {
|
||
let i = skip_jsws(s, pos + 1);
|
||
if s.get(i) == Some(&b'*') {
|
||
let j = skip_jsws(s, i + 1);
|
||
// \b holds: the previous char is `*` or whitespace.
|
||
if is_word_at(s, j) { Some(j) } else { None }
|
||
} else {
|
||
None
|
||
}
|
||
} else {
|
||
Some(pos)
|
||
};
|
||
let matched = name_start.and_then(|ns| {
|
||
let ne = word_end(s, ns);
|
||
let sub = subscript_span(s, skip_jsws(s, ne))?;
|
||
let end = close_call_tail(s, sub)?;
|
||
Some(((ns, ne), end))
|
||
});
|
||
match matched {
|
||
Some(((ns, ne), end)) => {
|
||
push_str(out, &s[ns..ne]);
|
||
pos = end;
|
||
}
|
||
None => pos += 1,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// INCLUDE_RE over RAW text: /#[ \t]*include[ \t]+"([^"\n]+)"/g
|
||
fn scan_includes(raw: &[u8], out: &mut Vec<String>) {
|
||
let mut pos = 0usize;
|
||
while pos < raw.len() {
|
||
let Some(h) = find_bytes(raw, b"#", pos) else { break };
|
||
let mut i = skip_sp_tab(raw, h + 1);
|
||
if raw.len() < i + 7 || &raw[i..i + 7] != b"include" {
|
||
pos = h + 1;
|
||
continue;
|
||
}
|
||
i += 7;
|
||
let q = skip_sp_tab(raw, i);
|
||
if q == i || raw.get(q) != Some(&b'"') {
|
||
pos = h + 1;
|
||
continue;
|
||
}
|
||
let mut j = q + 1;
|
||
while j < raw.len() && raw[j] != b'"' && raw[j] != b'\n' {
|
||
j += 1;
|
||
}
|
||
if j > q + 1 && j < raw.len() && raw[j] == b'"' {
|
||
out.push(bytes_to_string(&raw[q + 1..j]));
|
||
pos = j + 1;
|
||
} else {
|
||
pos = h + 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---------- struct field parsing ----------
|
||
|
||
/// splitTopLevel(body, sep): split on `sep` at brace/paren/bracket depth 0.
|
||
fn split_top_level(body: &[u8], sep: u8) -> Vec<Range> {
|
||
let mut out = Vec::new();
|
||
let mut depth = 0i64;
|
||
let mut start = 0usize;
|
||
for (i, &c) in body.iter().enumerate() {
|
||
match c {
|
||
b'{' | b'(' | b'[' => depth += 1,
|
||
b'}' | b')' | b']' => depth -= 1,
|
||
_ if c == sep && depth == 0 => {
|
||
out.push((start, i));
|
||
start = i + 1;
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
out.push((start, body.len()));
|
||
out
|
||
}
|
||
|
||
/// JS String.prototype.trim over bytes (the JS set == our jsws set).
|
||
fn jsws_trim(s: &[u8], mut a: usize, mut b: usize) -> (usize, usize) {
|
||
loop {
|
||
let l = jsws_len(s, a);
|
||
if l == 0 || a + l > b {
|
||
break;
|
||
}
|
||
a += l;
|
||
}
|
||
// Trailing: walk from the front to find the last non-ws position (ws
|
||
// lengths vary, so scan forward tracking the end of the last non-ws char).
|
||
let mut i = a;
|
||
let mut last_end = a;
|
||
while i < b {
|
||
let l = jsws_len(s, i);
|
||
if l == 0 {
|
||
i += 1;
|
||
last_end = i;
|
||
} else {
|
||
i += l;
|
||
}
|
||
}
|
||
b = last_end;
|
||
(a, b)
|
||
}
|
||
|
||
/// /(\w+)\s+\**\s*(\w+)\s*$/ — leftmost match whose tail reaches the end.
|
||
/// Deterministic per start (greedy words/ws cannot backtrack usefully);
|
||
/// candidate starts advance one byte at a time like the JS engine.
|
||
fn first_typed(part: &[u8]) -> Option<(Range, Range)> {
|
||
let n = part.len();
|
||
let mut p = 0usize;
|
||
while p < n {
|
||
if !is_word(part[p]) {
|
||
p += 1;
|
||
continue;
|
||
}
|
||
let te = word_end(part, p);
|
||
let w = skip_jsws(part, te);
|
||
if w == te {
|
||
p += 1;
|
||
continue;
|
||
}
|
||
let mut q = w;
|
||
while q < n && part[q] == b'*' {
|
||
q += 1;
|
||
}
|
||
let q = skip_jsws(part, q);
|
||
if is_word_at(part, q) {
|
||
let ne = word_end(part, q);
|
||
let t = skip_jsws(part, ne);
|
||
if t == n {
|
||
return Some(((p, te), (q, ne)));
|
||
}
|
||
}
|
||
p += 1;
|
||
}
|
||
None
|
||
}
|
||
|
||
/// FNPTR_DECL_RE (first match): /\(\s*(?:\w+\s+)*\*\s*(\w+)\s*\)\s*\(/
|
||
fn fnptr_decl(part: &[u8]) -> Option<Range> {
|
||
let mut i = 0usize;
|
||
while i < part.len() {
|
||
if part[i] == b'(' {
|
||
if let Some((name, _)) = fnptr_paren_tail(part, i) {
|
||
return Some(name);
|
||
}
|
||
}
|
||
i += 1;
|
||
}
|
||
None
|
||
}
|
||
|
||
/// Port of `parseStructFieldsRaw` — structure only, classification TS-side.
|
||
pub fn parse_struct_fields_raw(inner: &[u8]) -> Vec<RawField> {
|
||
let mut fields = Vec::new();
|
||
let mut idx: u32 = 0;
|
||
for (ds, de) in split_top_level(inner, b';') {
|
||
let (ds, de) = jsws_trim(inner, ds, de);
|
||
if ds >= de {
|
||
continue;
|
||
}
|
||
let decl = &inner[ds..de];
|
||
let parts = split_top_level(decl, b',');
|
||
let ft = first_typed(&decl[parts[0].0..parts[0].1]);
|
||
let shared_type: &[u8] = match &ft {
|
||
Some(((ts, te), _)) => &decl[parts[0].0 + ts..parts[0].0 + te],
|
||
None => b"",
|
||
};
|
||
for (pi, &(ps, pe)) in parts.iter().enumerate() {
|
||
let (ps2, pe2) = jsws_trim(decl, ps, pe);
|
||
let p = &decl[ps2..pe2];
|
||
let mut name: &[u8] = b"";
|
||
let mut ty: &[u8] = b"";
|
||
let mut ptr = false;
|
||
if let Some((ns, ne)) = fnptr_decl(p) {
|
||
name = &p[ns..ne];
|
||
ptr = true;
|
||
} else if pi == 0 {
|
||
if let Some((_, (ns, ne))) = &ft {
|
||
name = &decl[parts[0].0 + ns..parts[0].0 + ne];
|
||
ty = shared_type;
|
||
}
|
||
} else {
|
||
// /^\**\s*(\w+)/
|
||
let mut q = 0usize;
|
||
while q < p.len() && p[q] == b'*' {
|
||
q += 1;
|
||
}
|
||
let q = skip_jsws(p, q);
|
||
if is_word_at(p, q) {
|
||
name = &p[q..word_end(p, q)];
|
||
ty = shared_type;
|
||
}
|
||
}
|
||
fields.push(RawField {
|
||
name: bytes_to_string(name),
|
||
index: idx,
|
||
ptr,
|
||
ty: bytes_to_string(ty),
|
||
});
|
||
idx += 1;
|
||
}
|
||
}
|
||
fields
|
||
}
|
||
|
||
// ---------- per-file entry ----------
|
||
|
||
fn push_str(out: &mut Vec<String>, bytes: &[u8]) {
|
||
out.push(bytes_to_string(bytes));
|
||
}
|
||
|
||
#[inline]
|
||
fn bytes_to_string(bytes: &[u8]) -> String {
|
||
// All slice boundaries land on ASCII delimiters, so the content is valid
|
||
// UTF-8 whenever the input string was; lossy keeps us total anyway.
|
||
String::from_utf8_lossy(bytes).into_owned()
|
||
}
|
||
|
||
fn dedup_in_order(v: Vec<String>) -> Vec<String> {
|
||
let mut seen = std::collections::HashSet::new();
|
||
let mut out = Vec::with_capacity(v.len());
|
||
for x in v {
|
||
if seen.insert(x.clone()) {
|
||
out.push(x);
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// Line start offsets (byte offset of each line's first byte).
|
||
fn line_starts(s: &[u8]) -> Vec<usize> {
|
||
let mut out = vec![0usize];
|
||
for (i, &b) in s.iter().enumerate() {
|
||
if b == b'\n' {
|
||
out.push(i + 1);
|
||
}
|
||
}
|
||
out
|
||
}
|
||
|
||
/// Run the full extraction sweep for one file. `raw` is the file text exactly
|
||
/// as the TS side read it; `structs` are the file's struct-node extents.
|
||
pub fn scan_file(raw: &str, structs: &[StructExtent]) -> FileFacts {
|
||
let raw_b = raw.as_bytes();
|
||
let stripped = strip_c(raw_b);
|
||
let s: &[u8] = &stripped;
|
||
|
||
let mut facts = FileFacts {
|
||
fn_ptr_typedefs: Vec::new(),
|
||
fn_type_typedefs: Vec::new(),
|
||
structs: Vec::new(),
|
||
inline_ptr: false,
|
||
inline_types: Vec::new(),
|
||
inline_tags: Vec::new(),
|
||
init_tokens: Vec::new(),
|
||
array_elems: Vec::new(),
|
||
alias_names: Vec::new(),
|
||
d_pairs: Vec::new(),
|
||
dispatch_fields: Vec::new(),
|
||
array_dispatch_names: Vec::new(),
|
||
includes: Vec::new(),
|
||
};
|
||
|
||
// Typedefs (gated like the JS sweep — purely a fast path, the scans find
|
||
// nothing without the substring anyway).
|
||
if contains_bytes(s, b"typedef") {
|
||
scan_fnptr_typedefs(s, &mut facts.fn_ptr_typedefs);
|
||
scan_fntype_typedefs(s, &mut facts.fn_type_typedefs);
|
||
}
|
||
|
||
// Struct-node field declarations.
|
||
if !structs.is_empty() {
|
||
let lines = line_starts(s);
|
||
for st in structs {
|
||
let mut sf = StructFields { id: st.id.clone(), parsed: false, fields: Vec::new() };
|
||
// sliceLinesPre: falsy startLine → '' (never parses). end_line
|
||
// arrives with the TS side's `?? startLine` already applied; a
|
||
// slice whose end ≤ start is empty, exactly like Array.slice.
|
||
if st.start_line >= 1 {
|
||
let a = (st.start_line - 1) as usize;
|
||
let b = st.end_line as usize;
|
||
if a < lines.len() && b > a {
|
||
let body_start = lines[a];
|
||
// End of line (b-1): next line start minus the `\n`, or EOF.
|
||
let body_end = if b < lines.len() { lines[b] - 1 } else { s.len() };
|
||
let body = &s[body_start..body_end.max(body_start)];
|
||
if let Some(open) = body.iter().position(|&c| c == b'{') {
|
||
if let Some(close) = match_brace(body, open) {
|
||
sf.parsed = true;
|
||
sf.fields = parse_struct_fields_raw(&body[open + 1..close]);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
facts.structs.push(sf);
|
||
}
|
||
}
|
||
|
||
// Registration filters.
|
||
if contains_bytes(s, b"{") {
|
||
let inline = scan_inline_structs(s);
|
||
facts.inline_ptr = inline.ptr;
|
||
facts.inline_types = dedup_in_order(inline.types);
|
||
facts.inline_tags = dedup_in_order(inline.tags);
|
||
if contains_bytes(s, b"=") {
|
||
scan_anchored(s, init_body, &mut facts.init_tokens);
|
||
facts.init_tokens = dedup_in_order(std::mem::take(&mut facts.init_tokens));
|
||
scan_anchored(s, array_table_body, &mut facts.array_elems);
|
||
facts.array_elems = dedup_in_order(std::mem::take(&mut facts.array_elems));
|
||
}
|
||
}
|
||
|
||
// Alias-shaped object macros.
|
||
if contains_bytes(s, b"#define") || contains_bytes(s, b"# define") {
|
||
scan_alias_names(s, &mut facts.alias_names);
|
||
facts.alias_names = dedup_in_order(std::mem::take(&mut facts.alias_names));
|
||
}
|
||
|
||
// Propagation + dispatch filters.
|
||
if contains_bytes(s, b"=") {
|
||
scan_field_assign(s, &mut facts.d_pairs);
|
||
facts.d_pairs = dedup_in_order(std::mem::take(&mut facts.d_pairs));
|
||
}
|
||
scan_dispatch(s, &mut facts.dispatch_fields);
|
||
facts.dispatch_fields = dedup_in_order(std::mem::take(&mut facts.dispatch_fields));
|
||
scan_array_dispatch(s, &mut facts.array_dispatch_names);
|
||
facts.array_dispatch_names = dedup_in_order(std::mem::take(&mut facts.array_dispatch_names));
|
||
|
||
// Includes come from the RAW text (string contents survive there).
|
||
if contains_bytes(raw_b, b"include") {
|
||
scan_includes(raw_b, &mut facts.includes);
|
||
}
|
||
|
||
facts
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
fn facts(src: &str) -> FileFacts {
|
||
scan_file(src, &[])
|
||
}
|
||
|
||
#[test]
|
||
fn strip_blanks_comments_keeps_strings() {
|
||
let s = strip_c(b"a /* x\ny */ b // c\nd \"in//str\" e");
|
||
assert_eq!(&s, b"a \n b \nd \"in//str\" e".as_slice());
|
||
}
|
||
|
||
#[test]
|
||
fn typedef_forms() {
|
||
let f = facts("typedef void (*hook_fn)(int);\ntypedef void redisCommandProc(int c);\n");
|
||
assert_eq!(f.fn_ptr_typedefs, vec!["hook_fn"]);
|
||
assert_eq!(f.fn_type_typedefs, vec!["redisCommandProc"]);
|
||
}
|
||
|
||
#[test]
|
||
fn init_modifier_backtrack() {
|
||
// `static x = {` must match with type token `static` (the JS engine
|
||
// backtracks the modifier loop) — harmless downstream, but collected.
|
||
let f = facts("; static x = {1};\n; static struct cmd t[] = { {0} };");
|
||
assert!(f.init_tokens.contains(&"static".to_string()));
|
||
assert!(f.init_tokens.contains(&"cmd".to_string()));
|
||
}
|
||
|
||
#[test]
|
||
fn dispatch_backtracks_segments() {
|
||
let f = facts("int go(struct c *x){ x->cmd->proc(1); tbl[i](2); (*ops[k])(3); }");
|
||
assert!(f.dispatch_fields.contains(&"proc".to_string()));
|
||
assert!(f.array_dispatch_names.contains(&"tbl".to_string()));
|
||
assert!(f.array_dispatch_names.contains(&"ops".to_string()));
|
||
}
|
||
|
||
#[test]
|
||
fn field_assign_pairs() {
|
||
let f = facts("void g(void){ a->f = b->g; h.x = k.y; m == n; }");
|
||
assert!(f.d_pairs.contains(&"f\0g".to_string()));
|
||
assert!(f.d_pairs.contains(&"x\0y".to_string()));
|
||
assert_eq!(f.d_pairs.len(), 2);
|
||
}
|
||
|
||
#[test]
|
||
fn alias_shapes() {
|
||
let f = facts("#define A redisCommand\n#define B struct foo\n#define C 0x12\n#define D(x) x\n");
|
||
assert!(f.alias_names.contains(&"A".to_string()));
|
||
assert!(f.alias_names.contains(&"B".to_string()));
|
||
assert!(!f.alias_names.contains(&"C".to_string()));
|
||
assert!(!f.alias_names.contains(&"D".to_string()));
|
||
}
|
||
|
||
#[test]
|
||
fn includes_from_raw() {
|
||
let f = facts("#include \"commands.def\"\n// #include \"in-comment.h\"\n");
|
||
// Raw-text scan: the commented include IS captured (parity with the
|
||
// JS INCLUDE_RE over raw text).
|
||
assert_eq!(f.includes, vec!["commands.def", "in-comment.h"]);
|
||
}
|
||
}
|