Add support for const items

Author: eqrion

compile-tests/constant.rs

@@ -0,0 +1,10 @@
+const FOO: i32 = 10;
+const BAR: &'static libc::c_char = "hello world";
+
+#[repr(C)]
+struct Foo {
+    x: [i32; FOO],
+}
+
+#[no_mangle]
+extern "C" fn root(x: Foo) { }

src/bindgen/bindings.rs

@@ -8,24 +8,27 @@ use std::path;
 use std::fs;
 
 use bindgen::config::{Config, Language};
-use bindgen::ir::{ItemContainer, Function};
+use bindgen::ir::{Constant, ItemContainer, Function};
 use bindgen::monomorph::TemplateSpecialization;
 use bindgen::writer::{ListType, Source, SourceWriter};
 
 pub struct Bindings {
     config: Config,
+    constants: Vec<Constant>,
     items: Vec<ItemContainer>,
     functions: Vec<Function>,
     template_specializations: Vec<TemplateSpecialization>,
 }
 
 impl Bindings {
     pub fn new(config: Config,
+               constants: Vec<Constant>,
                items: Vec<ItemContainer>,
                functions: Vec<Function>,
                template_specializations: Vec<TemplateSpecialization>) -> Bindings {
         Bindings {
             config: config,
+            constants: constants,
             items: items,
             functions: functions,
             template_specializations: template_specializations,
@@ -89,13 +92,20 @@ impl Bindings {
             self.open_namespaces(&mut out);
         }
 
+        for constant in &self.constants {
+            out.new_line_if_not_start();
+            constant.write(&self.config, &mut out);
+            out.new_line();
+        }
+
         for item in &self.items {
             if item.deref().annotations().bool("no-export").unwrap_or(false) {
                 continue;
             }
 
             out.new_line_if_not_start();
             match item {
+                &ItemContainer::Constant(ref x) => x.write(&self.config, &mut out),
                 &ItemContainer::Enum(ref x) => x.write(&self.config, &mut out),
                 &ItemContainer::Struct(ref x) => x.write(&self.config, &mut out),
                 &ItemContainer::OpaqueItem(ref x) => x.write(&self.config, &mut out),

src/bindgen/builder.rs

@@ -8,7 +8,7 @@ use syn;
 
 use bindgen::cargo::Cargo;
 use bindgen::config::Config;
-use bindgen::ir::{AnnotationSet, Cfg, Documentation, Enum, Function};
+use bindgen::ir::{AnnotationSet, Cfg, Constant, Documentation, Enum, Function};
 use bindgen::ir::{ItemMap, OpaqueItem, Specialization, Struct, Typedef};
 use bindgen::library::Library;
 use bindgen::rust_lib;
@@ -80,6 +80,7 @@ impl LibraryBuilder {
         result.functions.sort_by(|x, y| x.name.cmp(&y.name));
 
         Ok(Library::new(self.config,
+                        result.constants,
                         result.enums,
                         result.structs,
                         result.opaque_items,
@@ -91,6 +92,7 @@ impl LibraryBuilder {
 
 #[derive(Debug, Clone)]
 struct LibraryParseResult {
+    constants: ItemMap<Constant>,
     enums: ItemMap<Enum>,
     structs: ItemMap<Struct>,
     opaque_items: ItemMap<OpaqueItem>,
@@ -103,6 +105,7 @@ impl LibraryParseResult {
     fn new() -> LibraryParseResult {
         LibraryParseResult {
             enums: ItemMap::new(),
+            constants: ItemMap::new(),
             structs: ItemMap::new(),
             opaque_items: ItemMap::new(),
             typedefs: ItemMap::new(),
@@ -168,6 +171,14 @@ impl LibraryParseResult {
                                      decl,
                                      abi);
                 }
+                syn::ItemKind::Const(ref ty, ref expr) => {
+                    self.load_syn_const(binding_crate_name,
+                                        crate_name,
+                                        mod_cfg,
+                                        item,
+                                        ty,
+                                        expr);
+                }
                 syn::ItemKind::Struct(ref variant, ref generics) => {
                     self.load_syn_struct(crate_name, mod_cfg, item, variant, generics);
                 }
@@ -275,6 +286,42 @@ impl LibraryParseResult {
         }
     }
 
+    /// Loads a `const` declaration
+    fn load_syn_const(&mut self,
+                      binding_crate_name: &str,
+                      crate_name: &str,
+                      mod_cfg: &Option<Cfg>,
+                      item: &syn::Item,
+                      ty: &syn::Ty,
+                      expr: &syn::Expr) {
+        if crate_name != binding_crate_name {
+            info!("Skip {}::{} - (const's outside of the binding crate are not used).",
+                  crate_name,
+                  &item.ident);
+            return;
+        }
+
+        let const_name = item.ident.to_string();
+
+        match Constant::load(const_name.clone(),
+                             ty,
+                             expr,
+                             &item.attrs,
+                             mod_cfg) {
+            Ok(constant) => {
+                info!("Take {}::{}.", crate_name, &item.ident);
+
+                self.constants.try_insert(constant);
+            }
+            Err(msg) => {
+                warn!("Skip {}::{} - ({})",
+                      crate_name,
+                      &item.ident,
+                      msg);
+            }
+        }
+    }
+
     /// Loads a `struct` declaration
     fn load_syn_struct(&mut self,
                        crate_name: &str,

src/bindgen/cdecl.rs

@@ -13,7 +13,7 @@ use bindgen::writer::SourceWriter;
 
 enum CDeclarator {
     Ptr(bool),
-    Array(u64),
+    Array(String),
     Func(Vec<(Option<String>, CDecl)>, bool),
 }
 
@@ -92,8 +92,8 @@ impl CDecl {
                 self.declarators.push(CDeclarator::Ptr(is_const));
                 self.build_type(t, false);
             }
-            &Type::Array(ref t, sz) => {
-                self.declarators.push(CDeclarator::Array(sz));
+            &Type::Array(ref t, ref constant) => {
+                self.declarators.push(CDeclarator::Array(constant.clone()));
                 self.build_type(t, false);
             }
             &Type::FuncPtr(ref ret, ref args) => {
@@ -164,11 +164,11 @@ impl CDecl {
                 &CDeclarator::Ptr(..) => {
                     last_was_pointer = true;
                 },
-                &CDeclarator::Array(sz) => {
+                &CDeclarator::Array(ref constant) => {
                     if last_was_pointer {
                         out.write(")");
                     }
-                    out.write(&format!("[{}]", sz));
+                    out.write(&format!("[{}]", constant));
 
                     last_was_pointer = false;
                 },

src/bindgen/config.rs

@@ -217,7 +217,7 @@ impl StructConfig {
 }
 
 /// Settings to apply to generated enums.
-#[derive( Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 #[serde(rename_all = "snake_case")]
 #[serde(deny_unknown_fields)]
 #[serde(default)]
@@ -250,6 +250,24 @@ impl EnumConfig {
     }
 }
 
+/// Settings to apply to generated constants.
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "snake_case")]
+#[serde(deny_unknown_fields)]
+#[serde(default)]
+pub struct ConstantConfig {
+    /// Whether a generated constant can be a static const in C++ mode.
+    pub allow_static_const: bool,
+}
+
+impl Default for ConstantConfig {
+    fn default() -> ConstantConfig {
+        ConstantConfig {
+            allow_static_const: true,
+        }
+    }
+}
+
 /// Settings to apply when parsing.
 #[derive( Debug, Clone, Deserialize)]
 #[serde(rename_all = "snake_case")]
@@ -323,6 +341,8 @@ pub struct Config {
     /// The configuration options for enums
     #[serde(rename = "enum")]
     pub enumeration: EnumConfig,
+    #[serde(rename = "const")]
+    pub constant: ConstantConfig,
     // Preprocessor defines to use when generating #ifdef's for #[cfg]
     pub defines: HashMap<String, String>,
     /// Include doc comments from rust as documentation
@@ -347,6 +367,7 @@ impl Default for Config {
             function: FunctionConfig::default(),
             structure: StructConfig::default(),
             enumeration: EnumConfig::default(),
+            constant: ConstantConfig::default(),
             defines: HashMap::new(),
             documentation: true,
         }

src/bindgen/ir/constant.rs

@@ -0,0 +1,145 @@
+/* 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 std::mem;
+
+use syn;
+
+use bindgen::config::{Config, Language};
+use bindgen::ir::{AnnotationSet, Cfg, Documentation, Item, ItemContainer, Specialization, Type};
+use bindgen::library::Library;
+use bindgen::writer::{Source, SourceWriter};
+
+#[derive(Debug, Clone)]
+pub struct LiteralExpr(String);
+
+impl LiteralExpr {
+    pub fn load(expr: &syn::Expr) -> Result<LiteralExpr, String> {
+        match &expr.node {
+            &syn::ExprKind::Lit(syn::Lit::Str(ref text, ..)) => {
+                Ok(LiteralExpr(format!("\"{}\"", text)))
+            }
+            &syn::ExprKind::Lit(syn::Lit::Byte(value)) => {
+                Ok(LiteralExpr(format!("{}", value)))
+            }
+            &syn::ExprKind::Lit(syn::Lit::Char(value)) => {
+                Ok(LiteralExpr(format!("{}", value)))
+            }
+            &syn::ExprKind::Lit(syn::Lit::Int(value, ref ty)) => {
+                match ty {
+                    &syn::IntTy::Usize |
+                    &syn::IntTy::U8 |
+                    &syn::IntTy::U16 |
+                    &syn::IntTy::U32 |
+                    &syn::IntTy::U64 |
+                    &syn::IntTy::Unsuffixed => {
+                        Ok(LiteralExpr(format!("{}", value)))
+                    }
+                    &syn::IntTy::Isize |
+                    &syn::IntTy::I8 |
+                    &syn::IntTy::I16 |
+                    &syn::IntTy::I32 |
+                    &syn::IntTy::I64 => {
+                        unsafe {
+                            Ok(LiteralExpr(format!("{}", mem::transmute::<u64, i64>(value))))
+                        }
+                    }
+                }
+            }
+            &syn::ExprKind::Lit(syn::Lit::Float(ref value, ref _ty)) => {
+                Ok(LiteralExpr(format!("{}", value)))
+            }
+            &syn::ExprKind::Lit(syn::Lit::Bool(value)) => {
+                Ok(LiteralExpr(format!("{}", value)))
+            }
+            _ => Err("Unsupported literal expression.".to_owned())
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Constant {
+    pub name: String,
+    pub ty: Type,
+    pub value: LiteralExpr,
+    pub cfg: Option<Cfg>,
+    pub annotations: AnnotationSet,
+    pub documentation: Documentation,
+}
+
+
+impl Constant {
+    pub fn load(name: String,
+                ty: &syn::Ty,
+                expr: &syn::Expr,
+                attrs: &Vec<syn::Attribute>,
+                mod_cfg: &Option<Cfg>) -> Result<Constant, String>
+    {
+        let ty = Type::load(ty)?;
+
+        if ty.is_none() {
+            return Err("Cannot have a zero sized const definition.".to_owned());
+        }
+
+        let ty = ty.unwrap();
+
+        if !ty.is_primitive_or_ptr_primitive() {
+            return Err("Cannot have a non primitive const definition.".to_owned());
+        }
+
+        Ok(Constant {
+            name: name,
+            ty: ty,
+            value: LiteralExpr::load(expr)?,
+            cfg: Cfg::append(mod_cfg, Cfg::load(attrs)),
+            annotations: AnnotationSet::load(attrs)?,
+            documentation: Documentation::load(attrs),
+        })
+    }
+}
+
+impl Item for Constant {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn cfg(&self) -> &Option<Cfg> {
+        &self.cfg
+    }
+
+    fn annotations(&self) -> &AnnotationSet {
+        &self.annotations
+    }
+
+    fn annotations_mut(&mut self) -> &mut AnnotationSet {
+        &mut self.annotations
+    }
+
+    fn container(&self) -> ItemContainer {
+        ItemContainer::Constant(self.clone())
+    }
+
+    fn specialize(&self, _library: &Library, _aliasee: &Specialization) -> Result<Box<Item>, String> {
+        unreachable!();
+    }
+}
+
+impl Source for Constant {
+    fn write<F: Write>(&self, config: &Config, out: &mut SourceWriter<F>) {
+        if config.constant.allow_static_const &&
+           config.language == Language::Cxx
+        {
+            if let Type::ConstPtr(..) = self.ty {
+                out.write("static ");
+            } else {
+                out.write("static const ");
+            }
+            self.ty.write(config, out);
+            out.write(&format!(" {} = {};", self.name, self.value.0))
+        } else {
+            out.write(&format!("#define {} {}", self.name, self.value.0))
+        }
+    }
+}