#![allow(non_upper_case_globals)]
use crate::diagnostic::{DiagnosticError, Severity};
use crate::extract::{extract_diagnostics, visit_function};
use anyhow::{Context, Result};
use clang_sys::*;
use std::ffi::CString;
use std::path::Path;
use std::process::Command;
use std::ptr;
fn discover_system_includes() -> Vec<String> {
let mut includes = Vec::new();
let output = Command::new("clang")
.args(["-E", "-x", "c", "-", "-v"])
.stdin(std::process::Stdio::null())
.output();
if let Ok(output) = output {
let stderr = String::from_utf8_lossy(&output.stderr);
let mut in_include_section = false;
for line in stderr.lines() {
if line.contains("#include <...> search starts here:") {
in_include_section = true;
continue;
}
if line.contains("End of search list.") {
break;
}
if in_include_section {
let path = line.trim();
if !path.is_empty() && !path.contains("(framework directory)") {
includes.push(path.to_string());
}
}
}
}
if includes.is_empty() {
if cfg!(target_os = "macos") {
includes.extend([
"/usr/local/include".to_string(),
"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include".to_string(),
]);
}
if cfg!(target_os = "linux") {
includes.extend(["/usr/include".to_string(), "/usr/local/include".to_string()]);
}
}
includes
}
#[derive(Debug)]
pub struct CParser {
index: CXIndex,
system_includes: Vec<String>,
}
impl CParser {
pub fn new() -> Result<Self> {
let index = unsafe { clang_createIndex(0, 0) };
if index.is_null() {
anyhow::bail!("Failed to create clang index");
}
let system_includes = discover_system_includes();
Ok(Self { index, system_includes })
}
#[allow(clippy::disallowed_methods)] pub fn parse(&self, source: &str) -> Result<Ast> {
let filename = CString::new("input.c").context("Failed to create filename")?;
let source_cstr = CString::new(source).context("Failed to convert source to CString")?;
let mut ast = Ast::new();
if source.trim().is_empty() {
return Ok(ast);
}
let unsaved_file = CXUnsavedFile {
Filename: filename.as_ptr(),
Contents: source_cstr.as_ptr(),
Length: source.len() as std::os::raw::c_ulong,
};
let has_extern_c = source.contains("extern \"C\"");
let has_ifdef_guard =
source.contains("#ifdef __cplusplus") || source.contains("#if defined(__cplusplus)");
let has_cuda_keywords = source.contains("__global__")
|| source.contains("__device__")
|| source.contains("__host__");
let needs_cpp_mode =
(has_extern_c && !has_ifdef_guard) || has_cuda_keywords;
let isystem_flag = CString::new("-isystem").unwrap();
let include_cstrings: Vec<CString> =
self.system_includes.iter().map(|p| CString::new(p.as_str()).unwrap()).collect();
let cpp_flag = CString::new("-x").unwrap();
let cpp_lang = CString::new("c++").unwrap();
let define_eof = CString::new("-DEOF=-1").unwrap();
let define_null = CString::new("-DNULL=0").unwrap();
let define_bufsiz = CString::new("-DBUFSIZ=8192").unwrap();
let define_global = CString::new("-D__global__=").unwrap();
let define_device = CString::new("-D__device__=").unwrap();
let define_host = CString::new("-D__host__=").unwrap();
let define_shared = CString::new("-D__shared__=").unwrap();
let mut args_vec: Vec<*const std::os::raw::c_char> = Vec::new();
if needs_cpp_mode {
args_vec.push(cpp_flag.as_ptr());
args_vec.push(cpp_lang.as_ptr());
}
if has_cuda_keywords {
args_vec.push(define_global.as_ptr());
args_vec.push(define_device.as_ptr());
args_vec.push(define_host.as_ptr());
args_vec.push(define_shared.as_ptr());
}
args_vec.push(define_eof.as_ptr());
args_vec.push(define_null.as_ptr());
args_vec.push(define_bufsiz.as_ptr());
for include_path in &include_cstrings {
args_vec.push(isystem_flag.as_ptr());
args_vec.push(include_path.as_ptr());
}
let flags = 1;
let mut tu = ptr::null_mut();
let result = unsafe {
clang_parseTranslationUnit2(
self.index,
filename.as_ptr(),
if args_vec.is_empty() { ptr::null() } else { args_vec.as_ptr() },
args_vec.len() as std::os::raw::c_int,
&unsaved_file as *const CXUnsavedFile as *mut CXUnsavedFile,
1,
flags,
&mut tu,
)
};
if result != CXError_Success || tu.is_null() {
anyhow::bail!("Failed to parse C source");
}
let diagnostics = extract_diagnostics(tu, source, None);
if diagnostics.iter().any(|d| d.severity >= Severity::Error) {
unsafe { clang_disposeTranslationUnit(tu) };
return Err(DiagnosticError::new(diagnostics).into());
}
let cursor = unsafe { clang_getTranslationUnitCursor(tu) };
let ast_ptr = &mut ast as *mut Ast;
unsafe {
clang_visitChildren(cursor, visit_function, ast_ptr as CXClientData);
clang_disposeTranslationUnit(tu);
}
if has_cuda_keywords {
apply_cuda_qualifiers_from_source(&mut ast, source);
}
Ok(ast)
}
#[allow(clippy::disallowed_methods)] pub fn parse_file(&self, path: &Path) -> Result<Ast> {
contract_pre_parse!();
let source = std::fs::read_to_string(path)
.with_context(|| format!("Failed to read file: {}", path.display()))?;
let abs_path = if path.is_absolute() {
path.to_path_buf()
} else {
std::env::current_dir()?.join(path)
};
let filename =
CString::new(abs_path.to_string_lossy().as_bytes()).context("Invalid path")?;
let source_cstr = CString::new(source.as_str()).context("Invalid source")?;
let mut ast = Ast::new();
if source.trim().is_empty() {
return Ok(ast);
}
let unsaved_file = CXUnsavedFile {
Filename: filename.as_ptr(),
Contents: source_cstr.as_ptr(),
Length: source.len() as std::os::raw::c_ulong,
};
let is_cpp_or_cuda_file = matches!(
path.extension().and_then(|s| s.to_str()),
Some("cu") | Some("cpp") | Some("cc") | Some("cxx") | Some("hpp")
);
let has_extern_c = source.contains("extern \"C\"");
let has_ifdef_guard =
source.contains("#ifdef __cplusplus") || source.contains("#if defined(__cplusplus)");
let needs_cpp_mode =
is_cpp_or_cuda_file || (has_extern_c && !has_ifdef_guard);
let cpp_flag = CString::new("-x").unwrap();
let cpp_lang = CString::new("c++").unwrap();
let define_eof = CString::new("-DEOF=-1").unwrap();
let define_null = CString::new("-DNULL=0").unwrap();
let define_bufsiz = CString::new("-DBUFSIZ=8192").unwrap();
let define_char_bit = CString::new("-DCHAR_BIT=8").unwrap();
let define_char_min = CString::new("-DCHAR_MIN=-128").unwrap();
let define_char_max = CString::new("-DCHAR_MAX=127").unwrap();
let define_schar_min = CString::new("-DSCHAR_MIN=-128").unwrap();
let define_schar_max = CString::new("-DSCHAR_MAX=127").unwrap();
let define_uchar_max = CString::new("-DUCHAR_MAX=255").unwrap();
let define_shrt_min = CString::new("-DSHRT_MIN=-32768").unwrap();
let define_shrt_max = CString::new("-DSHRT_MAX=32767").unwrap();
let define_ushrt_max = CString::new("-DUSHRT_MAX=65535").unwrap();
let define_int_min = CString::new("-DINT_MIN=-2147483648").unwrap();
let define_int_max = CString::new("-DINT_MAX=2147483647").unwrap();
let define_uint_max = CString::new("-DUINT_MAX=4294967295U").unwrap();
let define_long_min = CString::new("-DLONG_MIN=-9223372036854775808L").unwrap();
let define_long_max = CString::new("-DLONG_MAX=9223372036854775807L").unwrap();
let define_ulong_max = CString::new("-DULONG_MAX=18446744073709551615UL").unwrap();
let define_exit_success = CString::new("-DEXIT_SUCCESS=0").unwrap();
let define_exit_failure = CString::new("-DEXIT_FAILURE=1").unwrap();
let define_rand_max = CString::new("-DRAND_MAX=2147483647").unwrap();
let include_clang = CString::new("-I/usr/lib/llvm-14/lib/clang/14.0.0/include").unwrap();
let include_local = CString::new("-I/usr/local/include").unwrap();
let include_arch = CString::new("-I/usr/include/x86_64-linux-gnu").unwrap();
let include_usr = CString::new("-I/usr/include").unwrap();
let base_defines: Vec<*const std::os::raw::c_char> = vec![
define_eof.as_ptr(),
define_null.as_ptr(),
define_bufsiz.as_ptr(),
define_char_bit.as_ptr(),
define_char_min.as_ptr(),
define_char_max.as_ptr(),
define_schar_min.as_ptr(),
define_schar_max.as_ptr(),
define_uchar_max.as_ptr(),
define_shrt_min.as_ptr(),
define_shrt_max.as_ptr(),
define_ushrt_max.as_ptr(),
define_int_min.as_ptr(),
define_int_max.as_ptr(),
define_uint_max.as_ptr(),
define_long_min.as_ptr(),
define_long_max.as_ptr(),
define_ulong_max.as_ptr(),
define_exit_success.as_ptr(),
define_exit_failure.as_ptr(),
define_rand_max.as_ptr(),
include_clang.as_ptr(),
include_local.as_ptr(),
include_arch.as_ptr(),
include_usr.as_ptr(),
];
let args_vec: Vec<*const std::os::raw::c_char> = if needs_cpp_mode {
let mut args = vec![cpp_flag.as_ptr(), cpp_lang.as_ptr()];
args.extend(base_defines);
args
} else {
base_defines
};
let flags = 1;
let mut tu = ptr::null_mut();
let result = unsafe {
clang_parseTranslationUnit2(
self.index,
filename.as_ptr(),
if args_vec.is_empty() { ptr::null() } else { args_vec.as_ptr() },
args_vec.len() as std::os::raw::c_int,
&unsaved_file as *const CXUnsavedFile as *mut CXUnsavedFile,
1,
flags,
&mut tu,
)
};
if result != CXError_Success || tu.is_null() {
anyhow::bail!("Failed to parse C source file: {}", path.display());
}
let file_name = path.to_string_lossy().to_string();
let diagnostics = extract_diagnostics(tu, &source, Some(&file_name));
if diagnostics.iter().any(|d| d.severity >= Severity::Error) {
unsafe { clang_disposeTranslationUnit(tu) };
return Err(DiagnosticError::new(diagnostics).into());
}
let cursor = unsafe { clang_getTranslationUnitCursor(tu) };
let ast_ptr = &mut ast as *mut Ast;
unsafe {
clang_visitChildren(cursor, visit_function, ast_ptr as CXClientData);
clang_disposeTranslationUnit(tu);
}
Ok(ast)
}
}
impl Drop for CParser {
fn drop(&mut self) {
unsafe {
clang_disposeIndex(self.index);
}
}
}
pub use crate::ast_types::*;
fn apply_cuda_qualifiers_from_source(ast: &mut Ast, source: &str) {
contract_pre_qualifier_preservation!();
let mut qualifiers: std::collections::HashMap<String, CudaQualifier> =
std::collections::HashMap::new();
for line in source.lines() {
let trimmed = line.trim();
let qualifier = if trimmed.starts_with("__global__") {
Some(CudaQualifier::Global)
} else if (trimmed.starts_with("__device__") && trimmed.contains("__host__"))
|| (trimmed.starts_with("__host__") && trimmed.contains("__device__"))
{
Some(CudaQualifier::HostDevice)
} else if trimmed.starts_with("__device__") {
Some(CudaQualifier::Device)
} else if trimmed.starts_with("__host__") {
Some(CudaQualifier::Host)
} else {
None
};
if let Some(qual) = qualifier {
let after_qual = trimmed
.replace("__global__", "")
.replace("__device__", "")
.replace("__host__", "");
if let Some(paren_pos) = after_qual.find('(') {
let before_paren = after_qual[..paren_pos].trim();
if let Some(name) = before_paren.split_whitespace().last() {
let clean_name = name.trim_start_matches('*').trim_start_matches('&');
qualifiers.insert(clean_name.to_string(), qual);
}
}
}
}
for func in ast.functions_mut() {
if let Some(qual) = qualifiers.get(&func.name) {
func.cuda_qualifier = Some(*qual);
}
}
}
#[cfg(test)]
#[path = "parser_tests.rs"]
mod parser_tests;
#[cfg(test)]
#[path = "pointer_arithmetic_tests.rs"]
mod pointer_arithmetic_tests;
#[cfg(test)]
#[path = "break_continue_tests.rs"]
mod break_continue_tests;
#[cfg(test)]
#[path = "cpp_cuda_tests.rs"]
mod cpp_cuda_tests;