[cc] include_path, other minor fixes

Author: jgarzik

cc/cflow.rs

@@ -162,7 +162,6 @@ fn extract_calls_from_expr(
     expr: &posixutils_cc::parse::ast::Expr,
     strings: &StringTable,
     calls: &mut Vec<String>,
-    variables: &mut Vec<String>,
 ) {
     match &expr.kind {
         ExprKind::Call { func, args } => {
@@ -174,76 +173,70 @@ fn extract_calls_from_expr(
                 }
             }
             // Recurse into function expression and arguments
-            extract_calls_from_expr(func, strings, calls, variables);
+            extract_calls_from_expr(func, strings, calls);
             for arg in args {
-                extract_calls_from_expr(arg, strings, calls, variables);
-            }
-        }
-        ExprKind::Ident { name } => {
-            let var_name = strings.get(*name).to_string();
-            if !variables.contains(&var_name) {
-                variables.push(var_name);
+                extract_calls_from_expr(arg, strings, calls);
             }
         }
         ExprKind::Unary { operand, .. } => {
-            extract_calls_from_expr(operand, strings, calls, variables);
+            extract_calls_from_expr(operand, strings, calls);
         }
         ExprKind::Binary { left, right, .. } => {
-            extract_calls_from_expr(left, strings, calls, variables);
-            extract_calls_from_expr(right, strings, calls, variables);
+            extract_calls_from_expr(left, strings, calls);
+            extract_calls_from_expr(right, strings, calls);
         }
         ExprKind::Assign { target, value, .. } => {
-            extract_calls_from_expr(target, strings, calls, variables);
-            extract_calls_from_expr(value, strings, calls, variables);
+            extract_calls_from_expr(target, strings, calls);
+            extract_calls_from_expr(value, strings, calls);
         }
         ExprKind::PostInc(e) | ExprKind::PostDec(e) => {
-            extract_calls_from_expr(e, strings, calls, variables);
+            extract_calls_from_expr(e, strings, calls);
         }
         ExprKind::Conditional {
             cond,
             then_expr,
             else_expr,
         } => {
-            extract_calls_from_expr(cond, strings, calls, variables);
-            extract_calls_from_expr(then_expr, strings, calls, variables);
-            extract_calls_from_expr(else_expr, strings, calls, variables);
+            extract_calls_from_expr(cond, strings, calls);
+            extract_calls_from_expr(then_expr, strings, calls);
+            extract_calls_from_expr(else_expr, strings, calls);
         }
         ExprKind::Member { expr, .. } | ExprKind::Arrow { expr, .. } => {
-            extract_calls_from_expr(expr, strings, calls, variables);
+            extract_calls_from_expr(expr, strings, calls);
         }
         ExprKind::Index { array, index } => {
-            extract_calls_from_expr(array, strings, calls, variables);
-            extract_calls_from_expr(index, strings, calls, variables);
+            extract_calls_from_expr(array, strings, calls);
+            extract_calls_from_expr(index, strings, calls);
         }
         ExprKind::Cast { expr, .. } => {
-            extract_calls_from_expr(expr, strings, calls, variables);
+            extract_calls_from_expr(expr, strings, calls);
         }
         ExprKind::SizeofExpr(e) => {
-            extract_calls_from_expr(e, strings, calls, variables);
+            extract_calls_from_expr(e, strings, calls);
         }
         ExprKind::Comma(exprs) => {
             for e in exprs {
-                extract_calls_from_expr(e, strings, calls, variables);
+                extract_calls_from_expr(e, strings, calls);
             }
         }
         ExprKind::InitList { elements } | ExprKind::CompoundLiteral { elements, .. } => {
             for elem in elements {
-                extract_calls_from_expr(&elem.value, strings, calls, variables);
+                extract_calls_from_expr(&elem.value, strings, calls);
             }
         }
         // Variadic builtins
         ExprKind::VaStart { ap, .. } => {
-            extract_calls_from_expr(ap, strings, calls, variables);
+            extract_calls_from_expr(ap, strings, calls);
         }
         ExprKind::VaArg { ap, .. } => {
-            extract_calls_from_expr(ap, strings, calls, variables);
+            extract_calls_from_expr(ap, strings, calls);
         }
         ExprKind::VaEnd { ap } => {
-            extract_calls_from_expr(ap, strings, calls, variables);
+            extract_calls_from_expr(ap, strings, calls);
         }
         ExprKind::VaCopy { dest, src } => {
-            extract_calls_from_expr(dest, strings, calls, variables);
-            extract_calls_from_expr(src, strings, calls, variables);
+            extract_calls_from_expr(dest, strings, calls);
+            extract_calls_from_expr(src, strings, calls);
         }
         // Other builtins with arguments
         ExprKind::Bswap16 { arg }
@@ -259,35 +252,30 @@ fn extract_calls_from_expr(
         | ExprKind::Popcountl { arg }
         | ExprKind::Popcountll { arg }
         | ExprKind::Alloca { size: arg } => {
-            extract_calls_from_expr(arg, strings, calls, variables);
+            extract_calls_from_expr(arg, strings, calls);
         }
-        // Literals and other terminals - no recursion needed
+        // Literals, identifiers, and other terminals - no recursion needed
         _ => {}
     }
 }
 
 /// Walk a statement to find function calls
-fn extract_calls_from_stmt(
-    stmt: &Stmt,
-    strings: &StringTable,
-    calls: &mut Vec<String>,
-    variables: &mut Vec<String>,
-) {
+fn extract_calls_from_stmt(stmt: &Stmt, strings: &StringTable, calls: &mut Vec<String>) {
     match stmt {
         Stmt::Empty => {}
         Stmt::Expr(expr) => {
-            extract_calls_from_expr(expr, strings, calls, variables);
+            extract_calls_from_expr(expr, strings, calls);
         }
         Stmt::Block(items) => {
             for item in items {
                 match item {
                     posixutils_cc::parse::ast::BlockItem::Statement(s) => {
-                        extract_calls_from_stmt(s, strings, calls, variables);
+                        extract_calls_from_stmt(s, strings, calls);
                     }
                     posixutils_cc::parse::ast::BlockItem::Declaration(decl) => {
                         for d in &decl.declarators {
                             if let Some(init) = &d.init {
-                                extract_calls_from_expr(init, strings, calls, variables);
+                                extract_calls_from_expr(init, strings, calls);
                             }
                         }
                     }
@@ -299,19 +287,19 @@ fn extract_calls_from_stmt(
             then_stmt,
             else_stmt,
         } => {
-            extract_calls_from_expr(cond, strings, calls, variables);
-            extract_calls_from_stmt(then_stmt, strings, calls, variables);
+            extract_calls_from_expr(cond, strings, calls);
+            extract_calls_from_stmt(then_stmt, strings, calls);
             if let Some(else_s) = else_stmt {
-                extract_calls_from_stmt(else_s, strings, calls, variables);
+                extract_calls_from_stmt(else_s, strings, calls);
             }
         }
         Stmt::While { cond, body } => {
-            extract_calls_from_expr(cond, strings, calls, variables);
-            extract_calls_from_stmt(body, strings, calls, variables);
+            extract_calls_from_expr(cond, strings, calls);
+            extract_calls_from_stmt(body, strings, calls);
         }
         Stmt::DoWhile { body, cond } => {
-            extract_calls_from_stmt(body, strings, calls, variables);
-            extract_calls_from_expr(cond, strings, calls, variables);
+            extract_calls_from_stmt(body, strings, calls);
+            extract_calls_from_expr(cond, strings, calls);
         }
         Stmt::For {
             init,
@@ -322,37 +310,37 @@ fn extract_calls_from_stmt(
             if let Some(i) = init {
                 match i {
                     posixutils_cc::parse::ast::ForInit::Expression(e) => {
-                        extract_calls_from_expr(e, strings, calls, variables);
+                        extract_calls_from_expr(e, strings, calls);
                     }
                     posixutils_cc::parse::ast::ForInit::Declaration(d) => {
                         for decl in &d.declarators {
                             if let Some(init_expr) = &decl.init {
-                                extract_calls_from_expr(init_expr, strings, calls, variables);
+                                extract_calls_from_expr(init_expr, strings, calls);
                             }
                         }
                     }
                 }
             }
             if let Some(c) = cond {
-                extract_calls_from_expr(c, strings, calls, variables);
+                extract_calls_from_expr(c, strings, calls);
             }
             if let Some(p) = post {
-                extract_calls_from_expr(p, strings, calls, variables);
+                extract_calls_from_expr(p, strings, calls);
             }
-            extract_calls_from_stmt(body, strings, calls, variables);
+            extract_calls_from_stmt(body, strings, calls);
         }
         Stmt::Return(Some(expr)) => {
-            extract_calls_from_expr(expr, strings, calls, variables);
+            extract_calls_from_expr(expr, strings, calls);
         }
         Stmt::Switch { expr, body } => {
-            extract_calls_from_expr(expr, strings, calls, variables);
-            extract_calls_from_stmt(body, strings, calls, variables);
+            extract_calls_from_expr(expr, strings, calls);
+            extract_calls_from_stmt(body, strings, calls);
         }
         Stmt::Case(expr) => {
-            extract_calls_from_expr(expr, strings, calls, variables);
+            extract_calls_from_expr(expr, strings, calls);
         }
         Stmt::Label { stmt, .. } => {
-            extract_calls_from_stmt(stmt, strings, calls, variables);
+            extract_calls_from_stmt(stmt, strings, calls);
         }
         _ => {}
     }
@@ -441,6 +429,7 @@ fn process_file(
     graph: &mut CallGraph,
     defines: &[String],
     undefines: &[String],
+    include_paths: &[String],
 ) -> io::Result<()> {
     // Read file content
     let file = File::open(path)?;
@@ -462,8 +451,15 @@ fn process_file(
 
     // Preprocess
     let target = Target::host();
-    let preprocessed =
-        preprocess_with_defines(tokens, &target, &mut strings, path, defines, undefines);
+    let preprocessed = preprocess_with_defines(
+        tokens,
+        &target,
+        &mut strings,
+        path,
+        defines,
+        undefines,
+        include_paths,
+    );
 
     // Create symbol table and type table
     let mut symbols = SymbolTable::new();
@@ -487,11 +483,9 @@ fn process_file(
             let line = func.pos.line;
 
             let mut calls = Vec::new();
-            let mut _variables = Vec::new();
-            extract_calls_from_stmt(&func.body, &strings, &mut calls, &mut _variables);
+            extract_calls_from_stmt(&func.body, &strings, &mut calls);
 
-            // Filter out self-recursion representation for cleaner output
-            // and filter based on include options
+            // Filter calls based on include options (e.g., underscore names)
             calls.retain(|c| graph.should_include(c));
 
             let info = FunctionInfo {
@@ -642,6 +636,7 @@ fn main() -> ExitCode {
                     &mut graph,
                     &args.defines,
                     &args.undefines,
+                    &args.include_paths,
                 ) {
                     eprintln!("cflow: {}: {}", file, e);
                 }

cc/ctags.rs

@@ -23,7 +23,7 @@ use posixutils_cc::token::{preprocess_with_defines, StreamTable, Tokenizer};
 use posixutils_cc::types::TypeTable;
 use std::collections::BTreeMap;
 use std::fs::{self, File, OpenOptions};
-use std::io::{self, BufReader, Read, Write};
+use std::io::{self, Write};
 use std::path::Path;
 use std::process::ExitCode;
 
@@ -92,12 +92,6 @@ impl TagEntry {
 // Source File Processing
 // ============================================================================
 
-/// Read file contents and split into lines
-fn read_file_lines(path: &str) -> io::Result<Vec<String>> {
-    let content = fs::read_to_string(path)?;
-    Ok(content.lines().map(String::from).collect())
-}
-
 /// Get the line content for a given line number (1-based)
 fn get_line_content(lines: &[String], line_num: u32) -> String {
     if line_num == 0 || line_num as usize > lines.len() {
@@ -111,14 +105,9 @@ fn get_line_content(lines: &[String], line_num: u32) -> String {
 fn process_file(path: &str, streams: &mut StreamTable) -> io::Result<Vec<TagEntry>> {
     let mut tags = Vec::new();
 
-    // Read file content
-    let file = File::open(path)?;
-    let mut reader = BufReader::new(file);
-    let mut buffer = Vec::new();
-    reader.read_to_end(&mut buffer)?;
-
-    // Also read as lines for line content extraction
-    let lines = read_file_lines(path)?;
+    // Read file content once
+    let content = fs::read_to_string(path)?;
+    let lines: Vec<String> = content.lines().map(String::from).collect();
 
     // Extract macro tags first (before preprocessing removes them)
     extract_macro_tags(&lines, path, &mut tags);
@@ -131,7 +120,7 @@ fn process_file(path: &str, streams: &mut StreamTable) -> io::Result<Vec<TagEntr
 
     // Tokenize
     let tokens = {
-        let mut tokenizer = Tokenizer::new(&buffer, stream_id, &mut strings);
+        let mut tokenizer = Tokenizer::new(content.as_bytes(), stream_id, &mut strings);
         tokenizer.tokenize()
     };
 
@@ -144,6 +133,7 @@ fn process_file(path: &str, streams: &mut StreamTable) -> io::Result<Vec<TagEntr
         path,
         &[], // No extra defines
         &[], // No undefines
+        &[], // No include paths
     );
 
     // Create symbol table and type table
@@ -215,11 +205,46 @@ fn process_file(path: &str, streams: &mut StreamTable) -> io::Result<Vec<TagEntr
     Ok(tags)
 }
 
+/// Check whether a line contains a typedef definition for the given name.
+///
+/// This is a lightweight heuristic that:
+/// - Ignores anything following `//` or `/*` on the line.
+/// - Requires `typedef` to appear as a separate token.
+/// - Requires the typedef name to appear as an identifier-like token
+///   (allowing for trailing punctuation like `;` or `,`).
+fn is_typedef_line(line: &str, name: &str) -> bool {
+    // Strip off line comments and simple block comment starts.
+    let mut code = line;
+    if let Some(idx) = code.find("//") {
+        code = &code[..idx];
+    }
+    if let Some(idx) = code.find("/*") {
+        code = &code[..idx];
+    }
+    let code = code.trim();
+    if code.is_empty() {
+        return false;
+    }
+    let mut has_typedef = false;
+    let mut has_name = false;
+    for raw_token in code.split_whitespace() {
+        if raw_token == "typedef" {
+            has_typedef = true;
+            continue;
+        }
+        // Strip trailing non-identifier characters (e.g., ';', ',', ')').
+        let cleaned = raw_token.trim_end_matches(|c: char| !(c.is_alphanumeric() || c == '_'));
+        if cleaned == name {
+            has_name = true;
+        }
+    }
+    has_typedef && has_name
+}
+
 /// Find the line number where a typedef is defined
 fn find_typedef_line(lines: &[String], name: &str) -> Option<u32> {
     for (i, line) in lines.iter().enumerate() {
-        // Simple heuristic: look for "typedef ... name" or "typedef ... name;"
-        if line.contains("typedef") && line.contains(name) {
+        if is_typedef_line(line, name) {
             return Some((i + 1) as u32);
         }
     }