in src/bindgen/cdecl.rs [195:370]
fn write<F: Write, LB: LanguageBackend>(
&self,
language_backend: &mut LB,
out: &mut SourceWriter<F>,
ident: Option<&str>,
config: &Config,
) {
// Write the type-specifier and type-qualifier first
if !self.type_qualifers.is_empty() {
write!(out, "{} ", self.type_qualifers);
}
if config.language != Language::Cython {
if let Some(ref ctype) = self.type_ctype {
write!(out, "{} ", ctype.to_str());
}
}
write!(out, "{}", self.type_name);
if !self.type_generic_args.is_empty() {
out.write("<");
out.write_horizontal_source_list(
language_backend,
&self.type_generic_args,
ListType::Join(", "),
|language_backend, out, g| match *g {
GenericArgument::Type(ref ty) => language_backend.write_type(out, ty),
GenericArgument::Const(ref expr) => write!(out, "{}", expr.as_str()),
},
);
out.write(">");
}
// When we have an identifier, put a space between the type and the declarators
if ident.is_some() {
out.write(" ");
}
// Write the left part of declarators before the identifier
let mut iter_rev = self.declarators.iter().rev().peekable();
#[allow(clippy::while_let_on_iterator)]
while let Some(declarator) = iter_rev.next() {
let next_is_pointer = iter_rev.peek().is_some_and(|x| x.is_ptr());
match *declarator {
CDeclarator::Ptr {
is_const,
is_nullable,
is_ref,
} => {
out.write(if is_ref { "&" } else { "*" });
if is_const {
out.write("const ");
}
if !is_nullable && !is_ref && config.language != Language::Cython {
if let Some(attr) = &config.pointer.non_null_attribute {
write!(out, "{} ", attr);
}
}
}
CDeclarator::Array(..) => {
if next_is_pointer {
out.write("(");
}
}
CDeclarator::Func { .. } => {
if next_is_pointer {
out.write("(");
}
}
}
}
// Write the identifier
if let Some(ident) = ident {
write!(out, "{}", ident);
}
// Write the right part of declarators after the identifier
let mut iter = self.declarators.iter();
let mut last_was_pointer = false;
#[allow(clippy::while_let_on_iterator)]
while let Some(declarator) = iter.next() {
match *declarator {
CDeclarator::Ptr { .. } => {
last_was_pointer = true;
}
CDeclarator::Array(ref constant) => {
if last_was_pointer {
out.write(")");
}
write!(out, "[{}]", constant);
last_was_pointer = false;
}
CDeclarator::Func {
ref args,
ref layout,
never_return,
} => {
if last_was_pointer {
out.write(")");
}
out.write("(");
if args.is_empty() && config.language == Language::C {
out.write("void");
}
fn write_vertical<F: Write, LB: LanguageBackend>(
language_backend: &mut LB,
out: &mut SourceWriter<F>,
config: &Config,
args: &[(Option<String>, CDecl)],
) {
let align_length = out.line_length_for_align();
out.push_set_spaces(align_length);
for (i, (arg_ident, arg_ty)) in args.iter().enumerate() {
if i != 0 {
out.write(",");
out.new_line();
}
// Convert &Option<String> to Option<&str>
let arg_ident = arg_ident.as_ref().map(|x| x.as_ref());
arg_ty.write(language_backend, out, arg_ident, config);
}
out.pop_tab();
}
fn write_horizontal<F: Write, LB: LanguageBackend>(
language_backend: &mut LB,
out: &mut SourceWriter<F>,
config: &Config,
args: &[(Option<String>, CDecl)],
) {
for (i, (arg_ident, arg_ty)) in args.iter().enumerate() {
if i != 0 {
out.write(", ");
}
// Convert &Option<String> to Option<&str>
let arg_ident = arg_ident.as_ref().map(|x| x.as_ref());
arg_ty.write(language_backend, out, arg_ident, config);
}
}
match layout {
Layout::Vertical => write_vertical(language_backend, out, config, args),
Layout::Horizontal => write_horizontal(language_backend, out, config, args),
Layout::Auto => {
if !out.try_write(
|out| write_horizontal(language_backend, out, config, args),
config.line_length,
) {
write_vertical(language_backend, out, config, args)
}
}
}
out.write(")");
if never_return && config.language != Language::Cython {
if let Some(ref no_return_attr) = config.function.no_return {
out.write_fmt(format_args!(" {}", no_return_attr));
}
}
last_was_pointer = true;
}
}
}
}