use crate::ast_types::*;
use clang_sys::*;
use std::ffi::CStr;
use std::ptr;
use super::visit_statement;
use super::expressions::visit_variable_initializer;
pub(crate) fn extract_function(cursor: CXCursor) -> Option<Function> {
let name_cxstring = unsafe { clang_getCursorSpelling(cursor) };
let name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let name = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
name
};
let cx_type = unsafe { clang_getCursorType(cursor) };
let return_cx_type = unsafe { clang_getResultType(cx_type) };
let return_type = convert_type(return_cx_type)?;
let num_args = unsafe { clang_Cursor_getNumArguments(cursor) };
let mut parameters = Vec::new();
for i in 0..num_args {
let arg_cursor = unsafe { clang_Cursor_getArgument(cursor, i as u32) };
let param_name_cxstring = unsafe { clang_getCursorSpelling(arg_cursor) };
let param_name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(param_name_cxstring));
let name = c_str.to_string_lossy().into_owned();
clang_disposeString(param_name_cxstring);
name
};
let param_cx_type = unsafe { clang_getCursorType(arg_cursor) };
if let Some(param_type) = convert_type(param_cx_type) {
let is_pointee_const = unsafe {
if param_cx_type.kind == clang_sys::CXType_Pointer {
let pointee = clang_sys::clang_getPointeeType(param_cx_type);
clang_isConstQualifiedType(pointee) != 0
} else {
false
}
};
parameters.push(Parameter::new_with_const(param_name, param_type, is_pointee_const));
}
}
let mut body = Vec::new();
let body_ptr = &mut body as *mut Vec<Statement>;
unsafe {
clang_visitChildren(cursor, visit_statement, body_ptr as CXClientData);
}
let mut cuda_qualifier = None;
let cuda_qual_ptr = &mut cuda_qualifier as *mut Option<CudaQualifier>;
unsafe {
clang_visitChildren(cursor, visit_cuda_attrs, cuda_qual_ptr as CXClientData);
}
let mut func = Function::new_with_body(name, return_type, parameters, body);
func.cuda_qualifier = cuda_qualifier;
Some(func)
}
extern "C" fn visit_cuda_attrs(
cursor: CXCursor,
_parent: CXCursor,
client_data: CXClientData,
) -> CXChildVisitResult {
let kind = unsafe { clang_getCursorKind(cursor) };
let qual_ptr = client_data as *mut Option<CudaQualifier>;
match kind {
414 => {
unsafe { *qual_ptr = Some(CudaQualifier::Global) };
}
413 => {
unsafe {
*qual_ptr = match *qual_ptr {
Some(CudaQualifier::Host) => Some(CudaQualifier::HostDevice),
_ => Some(CudaQualifier::Device),
};
}
}
415 => {
unsafe {
*qual_ptr = match *qual_ptr {
Some(CudaQualifier::Device) => Some(CudaQualifier::HostDevice),
_ => Some(CudaQualifier::Host),
};
}
}
_ => {}
}
CXChildVisit_Continue
}
pub(crate) fn extract_class(cursor: CXCursor) -> Option<Class> {
contract_pre_class_to_struct!();
let name_cxstring = unsafe { clang_getCursorSpelling(cursor) };
let name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let n = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
n
};
if name.is_empty() {
return None;
}
let mut class = Class::new(name);
let class_ptr = &mut class as *mut Class;
unsafe {
clang_visitChildren(cursor, visit_class_children, class_ptr as CXClientData);
}
Some(class)
}
extern "C" fn visit_class_children(
cursor: CXCursor,
_parent: CXCursor,
client_data: CXClientData,
) -> CXChildVisitResult {
let class = unsafe { &mut *(client_data as *mut Class) };
let kind = unsafe { clang_getCursorKind(cursor) };
match kind {
6 => {
let field_name_cx = unsafe { clang_getCursorSpelling(cursor) };
let field_name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(field_name_cx));
let n = c_str.to_string_lossy().into_owned();
clang_disposeString(field_name_cx);
n
};
let field_type = unsafe { clang_getCursorType(cursor) };
if let Some(ft) = convert_type(field_type) {
class.fields.push(StructField::new(field_name, ft));
}
}
21 => {
if let Some(func) = extract_function(cursor) {
let is_const = unsafe { clang_CXXMethod_isConst(cursor) != 0 };
let is_static = unsafe { clang_CXXMethod_isStatic(cursor) != 0 };
let is_virtual = unsafe { clang_CXXMethod_isVirtual(cursor) != 0 };
let operator_kind = detect_operator_kind(&func.name);
class.methods.push(Method {
function: func,
access: AccessSpecifier::Public,
is_const,
is_static,
is_virtual,
operator_kind,
});
}
}
24 => {
let num_args = unsafe { clang_Cursor_getNumArguments(cursor) };
let mut params = Vec::new();
for i in 0..num_args {
let arg_cursor = unsafe { clang_Cursor_getArgument(cursor, i as u32) };
let param_name_cx = unsafe { clang_getCursorSpelling(arg_cursor) };
let param_name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(param_name_cx));
let n = c_str.to_string_lossy().into_owned();
clang_disposeString(param_name_cx);
n
};
let param_type = unsafe { clang_getCursorType(arg_cursor) };
if let Some(pt) = convert_type(param_type) {
params.push(Parameter::new(param_name, pt));
}
}
if class.constructor_params.is_empty() {
class.constructor_params = params;
}
}
25 => {
class.has_destructor = true;
}
44 => {
let base_name_cx = unsafe { clang_getCursorSpelling(cursor) };
let base_name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(base_name_cx));
let n = c_str.to_string_lossy().into_owned();
clang_disposeString(base_name_cx);
n
};
let stripped = base_name
.strip_prefix("class ")
.or_else(|| base_name.strip_prefix("struct "))
.unwrap_or(&base_name);
let clean_name = stripped
.rsplit("::")
.next()
.unwrap_or(stripped)
.to_string();
if !clean_name.is_empty() {
class.base_class = Some(clean_name);
}
}
_ => {}
}
CXChildVisit_Continue
}
fn detect_operator_kind(name: &str) -> Option<CxxOperatorKind> {
contract_pre_operator_to_trait!();
match name {
"operator+" => Some(CxxOperatorKind::Add),
"operator-" => Some(CxxOperatorKind::Sub),
"operator*" => Some(CxxOperatorKind::Mul),
"operator/" => Some(CxxOperatorKind::Div),
"operator%" => Some(CxxOperatorKind::Rem),
"operator==" => Some(CxxOperatorKind::Equal),
"operator!=" => Some(CxxOperatorKind::NotEqual),
"operator<" => Some(CxxOperatorKind::Less),
"operator<=" => Some(CxxOperatorKind::LessEqual),
"operator>" => Some(CxxOperatorKind::Greater),
"operator>=" => Some(CxxOperatorKind::GreaterEqual),
"operator[]" => Some(CxxOperatorKind::Index),
"operator<<" => Some(CxxOperatorKind::Shl),
"operator>>" => Some(CxxOperatorKind::Shr),
"operator+=" => Some(CxxOperatorKind::AddAssign),
"operator-=" => Some(CxxOperatorKind::SubAssign),
_ => None,
}
}
pub(crate) fn extract_namespace(cursor: CXCursor) -> Option<Namespace> {
contract_pre_namespace_to_mod!();
let name_cxstring = unsafe { clang_getCursorSpelling(cursor) };
let name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let n = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
n
};
let mut ns = Namespace::new(name);
let ns_ptr = &mut ns as *mut Namespace;
unsafe {
clang_visitChildren(cursor, visit_namespace_children, ns_ptr as CXClientData);
}
Some(ns)
}
extern "C" fn visit_namespace_children(
cursor: CXCursor,
_parent: CXCursor,
client_data: CXClientData,
) -> CXChildVisitResult {
let ns = unsafe { &mut *(client_data as *mut Namespace) };
let kind = unsafe { clang_getCursorKind(cursor) };
if kind == CXCursor_FunctionDecl {
if let Some(func) = extract_function(cursor) {
ns.functions.push(func);
}
} else if kind == CXCursor_StructDecl {
if let Some(s) = extract_struct(cursor) {
ns.structs.push(s);
}
} else if kind == 4 {
if let Some(class) = extract_class(cursor) {
ns.classes.push(class);
}
} else if kind == 22 {
if let Some(nested) = extract_namespace(cursor) {
ns.namespaces.push(nested);
}
}
CXChildVisit_Continue
}
pub(crate) fn extract_typedef(cursor: CXCursor) -> (Option<Typedef>, Option<Struct>) {
let name_cxstring = unsafe { clang_getCursorSpelling(cursor) };
let name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let name = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
name
};
let cx_type = unsafe { clang_getTypedefDeclUnderlyingType(cursor) };
let canonical = unsafe { clang_getCanonicalType(cx_type) };
if canonical.kind == CXType_Record {
let decl = unsafe { clang_getTypeDeclaration(canonical) };
let struct_name_cxstring = unsafe { clang_getCursorSpelling(decl) };
let struct_name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(struct_name_cxstring));
let sn = c_str.to_string_lossy().into_owned();
clang_disposeString(struct_name_cxstring);
sn
};
if struct_name.is_empty() {
let mut fields = Vec::new();
let fields_ptr = &mut fields as *mut Vec<StructField>;
unsafe {
clang_visitChildren(decl, visit_struct_fields, fields_ptr as CXClientData);
}
return (None, Some(Struct::new(name, fields)));
}
}
let underlying_type = convert_type(cx_type);
match underlying_type {
Some(ut) => (Some(Typedef::new(name, ut)), None),
None => (None, None),
}
}
pub(crate) fn extract_struct(cursor: CXCursor) -> Option<Struct> {
let name_cxstring = unsafe { clang_getCursorSpelling(cursor) };
let name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let name = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
name
};
if name.is_empty() {
return None;
}
let mut fields = Vec::new();
let fields_ptr = &mut fields as *mut Vec<StructField>;
unsafe {
clang_visitChildren(cursor, visit_struct_fields, fields_ptr as CXClientData);
}
Some(Struct::new(name, fields))
}
pub(crate) fn extract_enum(cursor: CXCursor) -> Option<Enum> {
let name_cxstring = unsafe { clang_getCursorSpelling(cursor) };
let name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let name = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
name
};
let mut variants: Vec<EnumVariant> = Vec::new();
let variants_ptr = &mut variants as *mut Vec<EnumVariant>;
extern "C" fn visit_enum_constants(
cursor: CXCursor,
_parent: CXCursor,
client_data: CXClientData,
) -> CXChildVisitResult {
let variants = unsafe { &mut *(client_data as *mut Vec<EnumVariant>) };
let kind = unsafe { clang_getCursorKind(cursor) };
if kind == 7 {
let name_cxstring = unsafe { clang_getCursorSpelling(cursor) };
let variant_name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let name = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
name
};
let value = unsafe { clang_getEnumConstantDeclValue(cursor) };
variants.push(EnumVariant::new(variant_name, Some(value)));
}
CXChildVisit_Continue
}
unsafe {
clang_visitChildren(cursor, visit_enum_constants, variants_ptr as CXClientData);
}
if variants.is_empty() {
return None;
}
Some(Enum::new(name, variants))
}
pub(crate) fn extract_variable(cursor: CXCursor) -> Option<Variable> {
let name_cxstring = unsafe { clang_getCursorSpelling(cursor) };
let name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let name = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
name
};
let cx_type = unsafe { clang_getCursorType(cursor) };
let var_type = convert_type(cx_type)?;
let storage_class = unsafe { clang_Cursor_getStorageClass(cursor) };
let is_static = storage_class == 3; let is_extern = storage_class == 2;
let is_const = unsafe { clang_isConstQualifiedType(cx_type) != 0 };
let mut initializer: Option<Expression> = None;
let initializer_ptr = &mut initializer as *mut Option<Expression>;
unsafe {
clang_visitChildren(cursor, visit_variable_initializer, initializer_ptr as CXClientData);
}
Some(Variable::new_with_storage_class(
name,
var_type,
initializer,
is_static,
is_extern,
is_const,
))
}
pub(crate) fn extract_macro(cursor: CXCursor) -> Option<MacroDefinition> {
let name_cxstring = unsafe { clang_getCursorSpelling(cursor) };
let name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let name = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
name
};
if name.is_empty() {
return None;
}
let is_function_like = unsafe { clang_sys::clang_Cursor_isMacroFunctionLike(cursor) } != 0;
let range = unsafe { clang_getCursorExtent(cursor) };
let tu = unsafe { clang_Cursor_getTranslationUnit(cursor) };
let mut tokens: *mut CXToken = ptr::null_mut();
let mut num_tokens: u32 = 0;
unsafe {
clang_tokenize(tu, range, &mut tokens, &mut num_tokens);
}
let mut parameters = Vec::new();
let mut body_tokens = Vec::new();
let mut in_params = false;
for i in 0..num_tokens {
let token = unsafe { *tokens.offset(i as isize) };
let token_kind = unsafe { clang_getTokenKind(token) };
let token_spelling = unsafe { clang_getTokenSpelling(tu, token) };
let token_str = unsafe {
let c_str = CStr::from_ptr(clang_getCString(token_spelling));
let s = c_str.to_string_lossy().into_owned();
clang_disposeString(token_spelling);
s
};
if i == 0 {
continue;
}
if is_function_like && i == 1 && token_str == "(" {
in_params = true;
continue;
}
if in_params {
if token_str == ")" {
in_params = false;
continue;
} else if token_str != ","
&& (token_kind == CXToken_Identifier || token_kind == CXToken_Keyword)
{
parameters.push(token_str);
}
} else {
body_tokens.push(token_str);
}
}
unsafe {
clang_disposeTokens(tu, tokens, num_tokens);
}
let body = body_tokens.join("");
if is_function_like {
Some(MacroDefinition::new_function_like(name, parameters, body))
} else {
Some(MacroDefinition::new_object_like(name, body))
}
}
pub(crate) extern "C" fn visit_struct_fields(
cursor: CXCursor,
_parent: CXCursor,
client_data: CXClientData,
) -> CXChildVisitResult {
let fields = unsafe { &mut *(client_data as *mut Vec<StructField>) };
let kind = unsafe { clang_getCursorKind(cursor) };
if kind == CXCursor_FieldDecl {
let name_cxstring = unsafe { clang_getCursorSpelling(cursor) };
let name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let name = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
name
};
let cx_type = unsafe { clang_getCursorType(cursor) };
if let Some(field_type) = convert_type(cx_type) {
fields.push(StructField::new(name, field_type));
}
}
CXChildVisit_Continue
}
pub(crate) fn convert_type(cx_type: CXType) -> Option<Type> {
match cx_type.kind {
CXType_Void => Some(Type::Void),
3 => Some(Type::Bool), CXType_Int => Some(Type::Int),
CXType_UInt => Some(Type::UnsignedInt), CXType_UChar => Some(Type::Char), CXType_UShort => Some(Type::UnsignedInt), CXType_ULong => Some(Type::UnsignedInt), CXType_Short => Some(Type::Int), CXType_Long => Some(Type::Int), CXType_LongLong => Some(Type::Int), CXType_ULongLong => Some(Type::UnsignedInt), CXType_Float => Some(Type::Float),
CXType_Double => Some(Type::Double),
23 => Some(Type::Double), CXType_Char_S | CXType_Char_U => Some(Type::Char),
14 => Some(Type::SignedChar), CXType_Pointer => {
let pointee = unsafe { clang_getPointeeType(cx_type) };
if pointee.kind == CXType_FunctionProto || pointee.kind == CXType_FunctionNoProto {
let return_cx_type = unsafe { clang_getResultType(pointee) };
let return_type = convert_type(return_cx_type)?;
let num_args = unsafe { clang_getNumArgTypes(pointee) };
let mut param_types = Vec::new();
for i in 0..num_args {
let arg_type = unsafe { clang_getArgType(pointee, i as u32) };
if let Some(param_type) = convert_type(arg_type) {
param_types.push(param_type);
}
}
return Some(Type::FunctionPointer {
param_types,
return_type: Box::new(return_type),
});
}
convert_type(pointee).map(|t| Type::Pointer(Box::new(t)))
}
CXType_FunctionProto | CXType_FunctionNoProto => {
let return_cx_type = unsafe { clang_getResultType(cx_type) };
let return_type = convert_type(return_cx_type)?;
let num_args = unsafe { clang_getNumArgTypes(cx_type) };
let mut param_types = Vec::new();
for i in 0..num_args {
let arg_type = unsafe { clang_getArgType(cx_type, i as u32) };
if let Some(param_type) = convert_type(arg_type) {
param_types.push(param_type);
}
}
Some(Type::FunctionPointer { param_types, return_type: Box::new(return_type) })
}
CXType_Record => {
let decl = unsafe { clang_getTypeDeclaration(cx_type) };
let name_cxstring = unsafe { clang_getCursorSpelling(decl) };
let name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(name_cxstring));
let struct_name = c_str.to_string_lossy().into_owned();
clang_disposeString(name_cxstring);
struct_name
};
Some(Type::Struct(name))
}
CXType_Elaborated => {
let canonical = unsafe { clang_getCanonicalType(cx_type) };
convert_type(canonical)
}
CXType_Typedef => {
let typedef_decl = unsafe { clang_getTypeDeclaration(cx_type) };
let typedef_name_cxstring = unsafe { clang_getCursorSpelling(typedef_decl) };
let typedef_name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(typedef_name_cxstring));
let tn = c_str.to_string_lossy().into_owned();
clang_disposeString(typedef_name_cxstring);
tn
};
match typedef_name.as_str() {
"size_t" | "ssize_t" | "ptrdiff_t" => {
return Some(Type::TypeAlias(typedef_name));
}
_ => {}
}
let canonical = unsafe { clang_getCanonicalType(cx_type) };
if canonical.kind == CXType_Record {
let decl = unsafe { clang_getTypeDeclaration(canonical) };
let struct_name_cxstring = unsafe { clang_getCursorSpelling(decl) };
let struct_name = unsafe {
let c_str = CStr::from_ptr(clang_getCString(struct_name_cxstring));
let sn = c_str.to_string_lossy().into_owned();
clang_disposeString(struct_name_cxstring);
sn
};
if struct_name.is_empty() {
return Some(Type::Struct(typedef_name));
}
}
convert_type(canonical)
}
CXType_ConstantArray => {
let element_cx_type = unsafe { clang_getArrayElementType(cx_type) };
let element_type = convert_type(element_cx_type)?;
let array_size = unsafe { clang_getArraySize(cx_type) };
let size = if array_size >= 0 { Some(array_size) } else { None };
Some(Type::Array { element_type: Box::new(element_type), size })
}
114 => {
let element_cx_type = unsafe { clang_getArrayElementType(cx_type) };
let element_type = convert_type(element_cx_type)?;
Some(Type::Array { element_type: Box::new(element_type), size: None })
}
106 => {
Some(Type::Int)
}
_ => None,
}
}