summaryrefslogtreecommitdiffstats
path: root/src/bindgen/ir/structure.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/bindgen/ir/structure.rs')
-rw-r--r--src/bindgen/ir/structure.rs717
1 files changed, 717 insertions, 0 deletions
diff --git a/src/bindgen/ir/structure.rs b/src/bindgen/ir/structure.rs
new file mode 100644
index 0000000..2eefa95
--- /dev/null
+++ b/src/bindgen/ir/structure.rs
@@ -0,0 +1,717 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use std::io::Write;
+
+use syn::ext::IdentExt;
+
+use crate::bindgen::config::{Config, Language, LayoutConfig};
+use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
+use crate::bindgen::dependencies::Dependencies;
+use crate::bindgen::ir::{
+ AnnotationSet, Cfg, ConditionWrite, Constant, DeprecatedNoteKind, Documentation, Field,
+ GenericArgument, GenericParams, Item, ItemContainer, Path, Repr, ReprAlign, ReprStyle,
+ ToCondition, Type, Typedef,
+};
+use crate::bindgen::library::Library;
+use crate::bindgen::mangle;
+use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::rename::{IdentifierType, RenameRule};
+use crate::bindgen::reserved;
+use crate::bindgen::utilities::IterHelpers;
+use crate::bindgen::writer::{ListType, Source, SourceWriter};
+
+#[derive(Debug, Clone)]
+pub struct Struct {
+ pub path: Path,
+ pub export_name: String,
+ pub generic_params: GenericParams,
+ pub fields: Vec<Field>,
+ /// Whether there's a tag field on the body of this struct. When this is
+ /// true, is_enum_variant_body is also guaranteed to be true.
+ pub has_tag_field: bool,
+ /// Whether this is an enum variant body.
+ pub is_enum_variant_body: bool,
+ pub alignment: Option<ReprAlign>,
+ pub is_transparent: bool,
+ pub cfg: Option<Cfg>,
+ pub annotations: AnnotationSet,
+ pub documentation: Documentation,
+ pub associated_constants: Vec<Constant>,
+}
+
+impl Struct {
+ /// Whether this struct can derive operator== / operator!=.
+ pub fn can_derive_eq(&self) -> bool {
+ !self.fields.is_empty() && self.fields.iter().all(|x| x.ty.can_cmp_eq())
+ }
+
+ pub fn add_associated_constant(&mut self, c: Constant) {
+ self.associated_constants.push(c);
+ }
+
+ pub fn load(
+ layout_config: &LayoutConfig,
+ item: &syn::ItemStruct,
+ mod_cfg: Option<&Cfg>,
+ ) -> Result<Self, String> {
+ let repr = Repr::load(&item.attrs)?;
+ let is_transparent = match repr.style {
+ ReprStyle::C => false,
+ ReprStyle::Transparent => true,
+ _ => {
+ return Err("Struct is not marked #[repr(C)] or #[repr(transparent)].".to_owned());
+ }
+ };
+
+ let path = Path::new(item.ident.unraw().to_string());
+
+ // Ensure we can safely represent the struct given the configuration.
+ if let Some(align) = repr.align {
+ layout_config.ensure_safe_to_represent(&align)?;
+ }
+
+ let fields = match item.fields {
+ syn::Fields::Unit => Vec::new(),
+ syn::Fields::Named(ref fields) => fields
+ .named
+ .iter()
+ .try_skip_map(|field| Field::load(field, &path))?,
+ syn::Fields::Unnamed(ref fields) => {
+ let mut out = Vec::new();
+ let mut current = 0;
+ for field in fields.unnamed.iter() {
+ if let Some(mut ty) = Type::load(&field.ty)? {
+ ty.replace_self_with(&path);
+ out.push(Field {
+ name: format!("{}", current),
+ ty,
+ cfg: Cfg::load(&field.attrs),
+ annotations: AnnotationSet::load(&field.attrs)?,
+ documentation: Documentation::load(&field.attrs),
+ });
+ current += 1;
+ }
+ }
+ out
+ }
+ };
+
+ let has_tag_field = false;
+ let is_enum_variant_body = false;
+
+ Ok(Struct::new(
+ path,
+ GenericParams::load(&item.generics)?,
+ fields,
+ has_tag_field,
+ is_enum_variant_body,
+ repr.align,
+ is_transparent,
+ Cfg::append(mod_cfg, Cfg::load(&item.attrs)),
+ AnnotationSet::load(&item.attrs)?,
+ Documentation::load(&item.attrs),
+ ))
+ }
+
+ #[allow(clippy::too_many_arguments)]
+ pub fn new(
+ path: Path,
+ generic_params: GenericParams,
+ fields: Vec<Field>,
+ has_tag_field: bool,
+ is_enum_variant_body: bool,
+ alignment: Option<ReprAlign>,
+ is_transparent: bool,
+ cfg: Option<Cfg>,
+ annotations: AnnotationSet,
+ documentation: Documentation,
+ ) -> Self {
+ let export_name = path.name().to_owned();
+ Self {
+ path,
+ export_name,
+ generic_params,
+ fields,
+ has_tag_field,
+ is_enum_variant_body,
+ alignment,
+ is_transparent,
+ cfg,
+ annotations,
+ documentation,
+ associated_constants: vec![],
+ }
+ }
+
+ pub fn simplify_standard_types(&mut self, config: &Config) {
+ for field in &mut self.fields {
+ field.ty.simplify_standard_types(config);
+ }
+ }
+
+ pub fn is_generic(&self) -> bool {
+ self.generic_params.len() > 0
+ }
+
+ pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
+ // Generic structs can instantiate monomorphs only once they've been
+ // instantiated. See `instantiate_monomorph` for more details.
+ if self.is_generic() {
+ return;
+ }
+
+ for field in &self.fields {
+ field.ty.add_monomorphs(library, out);
+ }
+ }
+
+ pub fn mangle_paths(&mut self, monomorphs: &Monomorphs) {
+ for field in &mut self.fields {
+ field.ty.mangle_paths(monomorphs);
+ }
+ }
+
+ pub fn specialize(
+ &self,
+ generic_values: &[GenericArgument],
+ mappings: &[(&Path, &GenericArgument)],
+ config: &Config,
+ ) -> Self {
+ let mangled_path = mangle::mangle_path(&self.path, generic_values, &config.export.mangle);
+ Struct::new(
+ mangled_path,
+ GenericParams::default(),
+ self.fields
+ .iter()
+ .map(|field| Field {
+ name: field.name.clone(),
+ ty: field.ty.specialize(mappings),
+ cfg: field.cfg.clone(),
+ annotations: field.annotations.clone(),
+ documentation: field.documentation.clone(),
+ })
+ .collect(),
+ self.has_tag_field,
+ self.is_enum_variant_body,
+ self.alignment,
+ self.is_transparent,
+ self.cfg.clone(),
+ self.annotations.clone(),
+ self.documentation.clone(),
+ )
+ }
+
+ fn emit_bitflags_binop<F: Write>(
+ &self,
+ constexpr_prefix: &str,
+ operator: char,
+ other: &str,
+ out: &mut SourceWriter<F>,
+ ) {
+ let bits = &self.fields[0].name;
+ out.new_line();
+ write!(
+ out,
+ "{}{} operator{}(const {}& {}) const",
+ constexpr_prefix,
+ self.export_name(),
+ operator,
+ self.export_name(),
+ other
+ );
+ out.open_brace();
+ write!(
+ out,
+ "return {} {{ static_cast<decltype({bits})>(this->{bits} {operator} {other}.{bits}) }};",
+ self.export_name()
+ );
+ out.close_brace(false);
+
+ out.new_line();
+ write!(
+ out,
+ "{}& operator{}=(const {}& {})",
+ self.export_name(),
+ operator,
+ self.export_name(),
+ other
+ );
+ out.open_brace();
+ write!(out, "*this = (*this {} {});", operator, other);
+ out.new_line();
+ write!(out, "return *this;");
+ out.close_brace(false);
+ }
+}
+
+impl Item for Struct {
+ fn path(&self) -> &Path {
+ &self.path
+ }
+
+ fn export_name(&self) -> &str {
+ &self.export_name
+ }
+
+ fn cfg(&self) -> Option<&Cfg> {
+ self.cfg.as_ref()
+ }
+
+ fn annotations(&self) -> &AnnotationSet {
+ &self.annotations
+ }
+
+ fn annotations_mut(&mut self) -> &mut AnnotationSet {
+ &mut self.annotations
+ }
+
+ fn container(&self) -> ItemContainer {
+ ItemContainer::Struct(self.clone())
+ }
+
+ fn collect_declaration_types(&self, resolver: &mut DeclarationTypeResolver) {
+ if self.is_transparent {
+ resolver.add_none(&self.path);
+ } else {
+ resolver.add_struct(&self.path);
+ }
+ }
+
+ fn resolve_declaration_types(&mut self, resolver: &DeclarationTypeResolver) {
+ for field in &mut self.fields {
+ field.ty.resolve_declaration_types(resolver);
+ }
+ }
+
+ fn rename_for_config(&mut self, config: &Config) {
+ // Rename the name of the struct
+ if !(self.has_tag_field && config.language == Language::Cxx) {
+ config.export.rename(&mut self.export_name);
+ }
+
+ // Rename the types used in fields
+ {
+ let fields = self.fields.iter_mut().skip(self.has_tag_field as usize);
+ for field in fields {
+ field.ty.rename_for_config(config, &self.generic_params);
+ }
+ }
+
+ // Apply renaming rules to fields in the following order
+ // 1. `cbindgen::field-names` annotation
+ // 2. `cbindgen::rename-all` annotation
+ // 3. config struct rename rule
+ // If the struct is a tuple struct and we have not renamed the
+ // fields, then prefix each of them with an underscore.
+ // If any field is a reserved keyword, then postfix it with an
+ // underscore.
+
+ // Scope for mutable borrow of fields
+ {
+ let names = self.fields.iter_mut().map(|field| &mut field.name);
+
+ let field_rules = self
+ .annotations
+ .parse_atom::<RenameRule>("rename-all")
+ .unwrap_or(config.structure.rename_fields);
+
+ if let Some(o) = self.annotations.list("field-names") {
+ for (dest, src) in names.zip(o) {
+ *dest = src;
+ }
+ } else if let Some(r) = field_rules.not_none() {
+ for name in names {
+ *name = r.apply(name, IdentifierType::StructMember).into_owned();
+ }
+ } else {
+ // If we don't have any rules for a tuple struct, prefix them with
+ // an underscore so it still compiles.
+ for name in names {
+ if name.starts_with(|c: char| c.is_ascii_digit()) {
+ name.insert(0, '_');
+ }
+ }
+ }
+ }
+
+ for field in &mut self.fields {
+ reserved::escape(&mut field.name);
+ }
+
+ for c in self.associated_constants.iter_mut() {
+ c.rename_for_config(config);
+ }
+ }
+
+ fn add_dependencies(&self, library: &Library, out: &mut Dependencies) {
+ let mut fields = self.fields.iter();
+
+ // If there is a tag field, skip it
+ if self.has_tag_field {
+ fields.next();
+ }
+
+ for field in fields {
+ field
+ .ty
+ .add_dependencies_ignoring_generics(&self.generic_params, library, out);
+ }
+
+ for c in &self.associated_constants {
+ c.add_dependencies(library, out);
+ }
+ }
+
+ fn instantiate_monomorph(
+ &self,
+ generic_values: &[GenericArgument],
+ library: &Library,
+ out: &mut Monomorphs,
+ ) {
+ let mappings = self.generic_params.call(self.path.name(), generic_values);
+ let monomorph = self.specialize(generic_values, &mappings, library.get_config());
+ out.insert_struct(library, self, monomorph, generic_values.to_owned());
+ }
+}
+
+impl Source for Struct {
+ fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+ if self.is_transparent {
+ let typedef = Typedef {
+ path: self.path.clone(),
+ export_name: self.export_name.to_owned(),
+ generic_params: self.generic_params.clone(),
+ aliased: self.fields[0].ty.clone(),
+ cfg: self.cfg.clone(),
+ annotations: self.annotations.clone(),
+ documentation: self.documentation.clone(),
+ };
+ typedef.write(config, out);
+ for constant in &self.associated_constants {
+ out.new_line();
+ constant.write(config, out, Some(self));
+ }
+ return;
+ }
+
+ let condition = self.cfg.to_condition(config);
+ condition.write_before(config, out);
+
+ self.documentation.write(config, out);
+
+ if !self.is_enum_variant_body {
+ self.generic_params.write(config, out);
+ }
+
+ // The following results in
+ // C++ or C with Tag as style:
+ // struct Name {
+ // C with Type only style:
+ // typedef struct {
+ // C with Both as style:
+ // typedef struct Name {
+ match config.language {
+ Language::C if config.style.generate_typedef() => out.write("typedef "),
+ Language::C | Language::Cxx => {}
+ Language::Cython => out.write(config.style.cython_def()),
+ }
+
+ // Cython extern declarations don't manage layouts, layouts are defined entierly by the
+ // corresponding C code. So this `packed` is only for documentation, and missing
+ // `aligned(n)` is also not a problem.
+ if config.language == Language::Cython {
+ if let Some(align) = self.alignment {
+ match align {
+ ReprAlign::Packed => out.write("packed "),
+ ReprAlign::Align(_) => {} // Not supported
+ }
+ }
+ }
+
+ out.write("struct");
+
+ if config.language != Language::Cython {
+ if let Some(align) = self.alignment {
+ match align {
+ ReprAlign::Packed => {
+ if let Some(ref anno) = config.layout.packed {
+ write!(out, " {}", anno);
+ }
+ }
+ ReprAlign::Align(n) => {
+ if let Some(ref anno) = config.layout.aligned_n {
+ write!(out, " {}({})", anno, n);
+ }
+ }
+ }
+ }
+ }
+
+ if self.annotations.must_use(config) {
+ if let Some(ref anno) = config.structure.must_use {
+ write!(out, " {}", anno);
+ }
+ }
+ if let Some(note) = self
+ .annotations
+ .deprecated_note(config, DeprecatedNoteKind::Struct)
+ {
+ write!(out, " {}", note);
+ }
+
+ if config.language != Language::C || config.style.generate_tag() {
+ write!(out, " {}", self.export_name());
+ }
+
+ out.open_brace();
+
+ // Emit the pre_body section, if relevant
+ if let Some(body) = config.export.pre_body(&self.path) {
+ out.write_raw_block(body);
+ out.new_line();
+ }
+
+ out.write_vertical_source_list(&self.fields, ListType::Cap(";"));
+ if config.language == Language::Cython && self.fields.is_empty() {
+ out.write("pass");
+ }
+
+ if config.language == Language::Cxx {
+ let mut wrote_start_newline = false;
+
+ if config.structure.derive_constructor(&self.annotations) && !self.fields.is_empty() {
+ if !wrote_start_newline {
+ wrote_start_newline = true;
+ out.new_line();
+ }
+
+ out.new_line();
+
+ let arg_renamer = |name: &str| {
+ config
+ .function
+ .rename_args
+ .apply(name, IdentifierType::FunctionArg)
+ .into_owned()
+ };
+ write!(out, "{}(", self.export_name());
+ let vec: Vec<_> = self
+ .fields
+ .iter()
+ .map(|field| {
+ Field::from_name_and_type(
+ // const-ref args to constructor
+ format!("const& {}", arg_renamer(&field.name)),
+ field.ty.clone(),
+ )
+ })
+ .collect();
+ out.write_vertical_source_list(&vec[..], ListType::Join(","));
+ write!(out, ")");
+ out.new_line();
+ write!(out, " : ");
+ let vec: Vec<_> = self
+ .fields
+ .iter()
+ .map(|field| format!("{}({})", field.name, arg_renamer(&field.name)))
+ .collect();
+ out.write_vertical_source_list(&vec[..], ListType::Join(","));
+ out.new_line();
+ write!(out, "{{}}");
+ out.new_line();
+ }
+
+ let other = config
+ .function
+ .rename_args
+ .apply("other", IdentifierType::FunctionArg);
+
+ if self
+ .annotations
+ .bool("internal-derive-bitflags")
+ .unwrap_or(false)
+ {
+ assert_eq!(self.fields.len(), 1);
+ let bits = &self.fields[0].name;
+ if !wrote_start_newline {
+ wrote_start_newline = true;
+ out.new_line();
+ }
+ let constexpr_prefix = if config.constant.allow_constexpr {
+ "constexpr "
+ } else {
+ ""
+ };
+
+ out.new_line();
+ write!(out, "{}explicit operator bool() const", constexpr_prefix);
+ out.open_brace();
+ write!(out, "return !!{bits};");
+ out.close_brace(false);
+
+ out.new_line();
+ write!(
+ out,
+ "{}{} operator~() const",
+ constexpr_prefix,
+ self.export_name()
+ );
+ out.open_brace();
+ write!(
+ out,
+ "return {} {{ static_cast<decltype({bits})>(~{bits}) }};",
+ self.export_name()
+ );
+ out.close_brace(false);
+ self.emit_bitflags_binop(constexpr_prefix, '|', &other, out);
+ self.emit_bitflags_binop(constexpr_prefix, '&', &other, out);
+ self.emit_bitflags_binop(constexpr_prefix, '^', &other, out);
+ }
+
+ // Generate a serializer function that allows dumping this struct
+ // to an std::ostream. It's defined as a friend function inside the
+ // struct definition, and doesn't need the `inline` keyword even
+ // though it's implemented right in the generated header file.
+ if config.structure.derive_ostream(&self.annotations) {
+ if !wrote_start_newline {
+ wrote_start_newline = true;
+ out.new_line();
+ }
+
+ out.new_line();
+ let stream = config
+ .function
+ .rename_args
+ .apply("stream", IdentifierType::FunctionArg);
+ let instance = config
+ .function
+ .rename_args
+ .apply("instance", IdentifierType::FunctionArg);
+ write!(
+ out,
+ "friend std::ostream& operator<<(std::ostream& {}, const {}& {})",
+ stream,
+ self.export_name(),
+ instance,
+ );
+ out.open_brace();
+ write!(out, "return {} << \"{{ \"", stream);
+ let vec: Vec<_> = self
+ .fields
+ .iter()
+ .map(|x| format!(" << \"{}=\" << {}.{}", x.name, instance, x.name))
+ .collect();
+ out.write_vertical_source_list(&vec[..], ListType::Join(" << \", \""));
+ out.write(" << \" }\";");
+ out.close_brace(false);
+ }
+
+ let skip_fields = self.has_tag_field as usize;
+
+ macro_rules! emit_op {
+ ($op_name:expr, $op:expr, $conjuc:expr) => {{
+ if !wrote_start_newline {
+ #[allow(unused_assignments)]
+ {
+ wrote_start_newline = true;
+ }
+ out.new_line();
+ }
+
+ out.new_line();
+
+ if let Some(Some(attrs)) =
+ self.annotations.atom(concat!($op_name, "-attributes"))
+ {
+ write!(out, "{} ", attrs);
+ }
+
+ write!(
+ out,
+ "bool operator{}(const {}& {}) const",
+ $op,
+ self.export_name(),
+ other
+ );
+ out.open_brace();
+ out.write("return ");
+ let vec: Vec<_> = self
+ .fields
+ .iter()
+ .skip(skip_fields)
+ .map(|field| format!("{} {} {}.{}", field.name, $op, other, field.name))
+ .collect();
+ out.write_vertical_source_list(
+ &vec[..],
+ ListType::Join(&format!(" {}", $conjuc)),
+ );
+ out.write(";");
+ out.close_brace(false);
+ }};
+ }
+
+ if config.structure.derive_eq(&self.annotations) && self.can_derive_eq() {
+ emit_op!("eq", "==", "&&");
+ }
+ if config.structure.derive_neq(&self.annotations) && self.can_derive_eq() {
+ emit_op!("neq", "!=", "||");
+ }
+ if config.structure.derive_lt(&self.annotations)
+ && self.fields.len() == 1
+ && self.fields[0].ty.can_cmp_order()
+ {
+ emit_op!("lt", "<", "&&");
+ }
+ if config.structure.derive_lte(&self.annotations)
+ && self.fields.len() == 1
+ && self.fields[0].ty.can_cmp_order()
+ {
+ emit_op!("lte", "<=", "&&");
+ }
+ if config.structure.derive_gt(&self.annotations)
+ && self.fields.len() == 1
+ && self.fields[0].ty.can_cmp_order()
+ {
+ emit_op!("gt", ">", "&&");
+ }
+ if config.structure.derive_gte(&self.annotations)
+ && self.fields.len() == 1
+ && self.fields[0].ty.can_cmp_order()
+ {
+ emit_op!("gte", ">=", "&&");
+ }
+ }
+
+ // Emit the post_body section, if relevant
+ if let Some(body) = config.export.post_body(&self.path) {
+ out.new_line();
+ out.write_raw_block(body);
+ }
+
+ if config.language == Language::Cxx
+ && config.structure.associated_constants_in_body
+ && config.constant.allow_static_const
+ {
+ for constant in &self.associated_constants {
+ out.new_line();
+ constant.write_declaration(config, out, self);
+ }
+ }
+
+ if config.language == Language::C && config.style.generate_typedef() {
+ out.close_brace(false);
+ write!(out, " {};", self.export_name());
+ } else {
+ out.close_brace(true);
+ }
+
+ for constant in &self.associated_constants {
+ out.new_line();
+ constant.write(config, out, Some(self));
+ }
+
+ condition.write_after(config, out);
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-09 21:04:04 +0000