Multiple constant generation evaluation improvements.

Author: emilio

libbindgen/src/clang.rs

@@ -1267,36 +1267,56 @@ pub fn extract_clang_version() -> String {
     unsafe { clang_getClangVersion().into() }
 }
 
+/// A wrapper for the result of evaluating an expression.
 #[derive(Debug)]
 pub struct EvalResult {
     x: CXEvalResult,
 }
 
 #[cfg(feature = "llvm_stable")]
 impl EvalResult {
+    /// Create a dummy EvalResult.
     pub fn new(_: Cursor) -> Self {
         EvalResult {
             x: ::std::ptr::null_mut(),
         }
     }
 
+    /// Not useful in llvm 3.8.
+    pub fn as_double(&self) -> Option<f64> {
+        None
+    }
+
+    /// Not useful in llvm 3.8.
     pub fn as_int(&self) -> Option<i32> {
         None
     }
 }
 
 #[cfg(not(feature = "llvm_stable"))]
 impl EvalResult {
+    /// Evaluate `cursor` and return the result.
     pub fn new(cursor: Cursor) -> Self {
         EvalResult {
             x: unsafe { clang_Cursor_Evaluate(cursor.x) },
         }
     }
 
-    pub fn kind(&self) -> Enum_CXEvalResultKind {
+    fn kind(&self) -> Enum_CXEvalResultKind {
         unsafe { clang_EvalResult_getKind(self.x) }
     }
 
+    /// Try to get back the result as a double.
+    pub fn as_double(&self) -> Option<f64> {
+        match self.kind() {
+            CXEval_Float => {
+                Some(unsafe { clang_EvalResult_getAsDouble(self.x) } as f64)
+            }
+            _ => None,
+        }
+    }
+
+    /// Try to get back the result as an integer.
     pub fn as_int(&self) -> Option<i32> {
         match self.kind() {
             CXEval_Int => {

libbindgen/src/codegen/helpers.rs

@@ -132,4 +132,37 @@ pub mod ast_ty {
             expr.int(val)
         }
     }
+
+    pub fn byte_array_expr(bytes: &[u8]) -> P<ast::Expr> {
+        let mut vec = Vec::with_capacity(bytes.len() + 1);
+        for byte in bytes {
+            vec.push(int_expr(*byte as i64));
+        }
+        vec.push(int_expr(0));
+
+        let kind = ast::ExprKind::Vec(vec);
+
+        aster::AstBuilder::new().expr().build_expr_kind(kind)
+    }
+
+    pub fn cstr_expr(mut string: String) -> P<ast::Expr> {
+        string.push('\0');
+        aster::AstBuilder::new()
+            .expr()
+            .build_lit(aster::AstBuilder::new().lit().byte_str(string))
+    }
+
+    pub fn float_expr(f: f64) -> P<ast::Expr> {
+        use aster::str::ToInternedString;
+        let mut string = f.to_string();
+
+        // So it gets properly recognised as a floating point constant.
+        if !string.contains('.') {
+            string.push('.');
+        }
+
+        let interned_str = string.as_str().to_interned_string();
+        let kind = ast::LitKind::FloatUnsuffixed(interned_str);
+        aster::AstBuilder::new().expr().lit().build_lit(kind)
+    }
 }

libbindgen/src/codegen/mod.rs

@@ -304,6 +304,7 @@ impl CodeGenerator for Var {
                ctx: &BindgenContext,
                result: &mut CodegenResult,
                item: &Item) {
+        use ir::var::VarType;
         debug!("<Var as CodeGenerator>::codegen: item = {:?}", item);
 
         let canonical_name = item.canonical_name(ctx);
@@ -320,10 +321,44 @@ impl CodeGenerator for Var {
                 .item()
                 .pub_()
                 .const_(canonical_name)
-                .expr()
-                .build(helpers::ast_ty::int_expr(val))
-                .build(ty);
-            result.push(const_item)
+                .expr();
+            let item = match *val {
+                VarType::Int(val) => {
+                    const_item.build(helpers::ast_ty::int_expr(val))
+                        .build(ty)
+                }
+                VarType::String(ref bytes) => {
+                    // Account the trailing zero.
+                    //
+                    // TODO: Here we ignore the type we just made up, probably
+                    // we should refactor how the variable type and ty id work.
+                    let len = bytes.len() + 1;
+                    let ty = quote_ty!(ctx.ext_cx(), [u8; $len]);
+
+                    match String::from_utf8(bytes.clone()) {
+                        Ok(string) => {
+                            const_item.build(helpers::ast_ty::cstr_expr(string))
+                                .build(quote_ty!(ctx.ext_cx(), &'static $ty))
+                        }
+                        Err(..) => {
+                            const_item
+                                .build(helpers::ast_ty::byte_array_expr(bytes))
+                                .build(ty)
+                        }
+                    }
+                }
+                VarType::Float(f) => {
+                    const_item.build(helpers::ast_ty::float_expr(f))
+                        .build(ty)
+                }
+                VarType::Char(c) => {
+                    const_item
+                        .build(aster::AstBuilder::new().expr().lit().byte(c))
+                        .build(ty)
+                }
+            };
+
+            result.push(item);
         } else {
             let mut attrs = vec![];
             if let Some(mangled) = self.mangled_name() {

libbindgen/src/ir/item.rs

@@ -840,11 +840,7 @@ impl ClangItemParser for Item {
                       ctx: &mut BindgenContext)
                       -> ItemId {
         let id = ctx.next_item_id();
-        Self::from_ty_or_ref_with_id(id,
-                                     ty,
-                                     location,
-                                     parent_id,
-                                     ctx)
+        Self::from_ty_or_ref_with_id(id, ty, location, parent_id, ctx)
     }
 
     /// Parse a C++ type. If we find a reference to a type that has not been

libbindgen/src/ir/ty.rs

@@ -123,6 +123,14 @@ impl Type {
         Self::new(Some(name), None, kind, false)
     }
 
+    /// Is this an floating point type?
+    pub fn is_float(&self) -> bool {
+        match self.kind {
+            TypeKind::Float(..) => true,
+            _ => false,
+        }
+    }
+
     /// Is this an integer type?
     pub fn is_integer(&self) -> bool {
         match self.kind {

libbindgen/src/ir/var.rs

@@ -8,7 +8,15 @@ use super::context::{BindgenContext, ItemId};
 use super::function::cursor_mangling;
 use super::int::IntKind;
 use super::item::Item;
-use super::ty::TypeKind;
+use super::ty::{FloatKind, TypeKind};
+
+#[derive(Debug)]
+pub enum VarType {
+    Int(i64),
+    Float(f64),
+    Char(u8),
+    String(Vec<u8>),
+}
 
 /// A `Var` is our intermediate representation of a variable.
 #[derive(Debug)]
@@ -19,9 +27,8 @@ pub struct Var {
     mangled_name: Option<String>,
     /// The type of the variable.
     ty: ItemId,
-    /// TODO: support non-integer constants?
-    /// The integer value of the variable.
-    val: Option<i64>,
+    /// The value of the variable, that needs to be suitable for `ty`.
+    val: Option<VarType>,
     /// Whether this variable is const.
     is_const: bool,
 }
@@ -31,7 +38,7 @@ impl Var {
     pub fn new(name: String,
                mangled: Option<String>,
                ty: ItemId,
-               val: Option<i64>,
+               val: Option<VarType>,
                is_const: bool)
                -> Var {
         assert!(!name.is_empty());
@@ -50,8 +57,8 @@ impl Var {
     }
 
     /// The value of this constant variable, if any.
-    pub fn val(&self) -> Option<i64> {
-        self.val
+    pub fn val(&self) -> Option<&VarType> {
+        self.val.as_ref()
     }
 
     /// Get this variable's type.
@@ -76,6 +83,7 @@ impl ClangSubItemParser for Var {
              -> Result<ParseResult<Self>, ParseError> {
         use clangll::*;
         use cexpr::expr::EvalResult;
+        use cexpr::literal::CChar;
         match cursor.kind() {
             CXCursor_MacroDefinition => {
                 let value = parse_macro(ctx, &cursor, ctx.translation_unit());
@@ -105,13 +113,32 @@ impl ClangSubItemParser for Var {
                 // enforce utf8 there, so we should have already panicked at
                 // this point.
                 let name = String::from_utf8(id).unwrap();
-                let (int_kind, val) = match value {
-                    // TODO(emilio): Handle the non-invalid ones!
-                    EvalResult::Float(..) |
-                    EvalResult::Char(..) |
-                    EvalResult::Str(..) |
+                let (type_kind, val) = match value {
                     EvalResult::Invalid => return Err(ParseError::Continue),
-
+                    EvalResult::Float(f) => {
+                        (TypeKind::Float(FloatKind::Float), VarType::Float(f))
+                    }
+                    EvalResult::Char(c) => {
+                        let c = match c {
+                            CChar::Char(c) => {
+                                assert_eq!(c.len_utf8(), 1);
+                                c as u8
+                            }
+                            CChar::Raw(c) => {
+                                assert!(c <= ::std::u8::MAX as u64);
+                                c as u8
+                            }
+                        };
+
+                        (TypeKind::Int(IntKind::U8), VarType::Char(c))
+                    }
+                    EvalResult::Str(val) => {
+                        let char_ty =
+                            Item::builtin_type(TypeKind::Int(IntKind::U8),
+                                               true,
+                                               ctx);
+                        (TypeKind::Pointer(char_ty), VarType::String(val))
+                    }
                     EvalResult::Int(Wrapping(value)) => {
                         let kind = ctx.options()
                             .type_chooser
@@ -131,11 +158,11 @@ impl ClangSubItemParser for Var {
                                 }
                             });
 
-                        (kind, value)
+                        (TypeKind::Int(kind), VarType::Int(value))
                     }
                 };
 
-                let ty = Item::builtin_type(TypeKind::Int(int_kind), true, ctx);
+                let ty = Item::builtin_type(type_kind, true, ctx);
 
                 Ok(ParseResult::New(Var::new(name, None, ty, Some(val), true),
                                     Some(cursor)))
@@ -159,11 +186,16 @@ impl ClangSubItemParser for Var {
                 // tests/headers/inner_const.hpp
                 //
                 // That's fine because in that case we know it's not a literal.
-                let is_integer = ctx.safe_resolve_type(ty)
-                    .and_then(|t| t.safe_canonical_type(ctx))
-                    .map(|t| t.is_integer())
-                    .unwrap_or(false);
+                let canonical_ty = ctx.safe_resolve_type(ty)
+                    .and_then(|t| t.safe_canonical_type(ctx));
 
+                let is_integer = canonical_ty.map_or(false, |t| t.is_integer());
+                let is_float = canonical_ty.map_or(false, |t| t.is_float());
+
+                // TODO: We could handle `char` more gracefully.
+                // TODO: Strings, though the lookup is a bit more hard (we need
+                // to look at the canonical type of the pointee too, and check
+                // is char, u8, or i8 I guess).
                 let value = if is_integer {
                     cursor.evaluate()
                         .as_int()
@@ -172,16 +204,19 @@ impl ClangSubItemParser for Var {
                             let tu = ctx.translation_unit();
                             get_integer_literal_from_cursor(&cursor, tu)
                         })
+                        .map(VarType::Int)
+                } else if is_float {
+                    cursor.evaluate()
+                        .as_double()
+                        .map(VarType::Float)
                 } else {
                     None
                 };
 
-
                 let mangling = cursor_mangling(&cursor);
-
                 let var = Var::new(name, mangling, ty, value, is_const);
-                Ok(ParseResult::New(var, Some(cursor)))
 
+                Ok(ParseResult::New(var, Some(cursor)))
             }
             _ => {
                 /* TODO */

tests/expectations/tests/constant-evaluate.rs renamed to libbindgen/tests/expectations/tests/constant-evaluate.rs

@@ -10,3 +10,6 @@ pub const bar: _bindgen_ty_1 = _bindgen_ty_1::bar;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum _bindgen_ty_1 { foo = 4, bar = 8, }
 pub const BAZ: ::std::os::raw::c_longlong = 24;
+pub const fuzz: f64 = 51.;
+pub const BAZZ: ::std::os::raw::c_char = 53;
+pub const WAT: ::std::os::raw::c_char = 0;

libbindgen/tests/expectations/tests/macro_const.rs

@@ -0,0 +1,12 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+pub const foo: &'static [u8; 4usize] = b"bar\x00";
+pub const CHAR: u8 = b'b';
+pub const CHARR: u8 = b'\x00';
+pub const FLOAT: f32 = 5.09;
+pub const FLOAT_EXPR: f32 = 0.005;
+pub const INVALID_UTF8: [u8; 5usize] = [240, 40, 140, 40, 0];

tests/expectations/tests/type_alias_partial_template_especialization.rs renamed to libbindgen/tests/expectations/tests/type_alias_partial_template_especialization.rs

@@ -0,0 +1,11 @@
+// bindgen-unstable
+
+enum {
+  foo = 4,
+  bar = 8,
+};
+
+const long long BAZ = (1 << foo) | bar;
+const double fuzz = (1 + 50.0f);
+const char BAZZ = '5';
+const char WAT = '\0';

tests/expectations/tests/type_alias_template_specialized.rs renamed to libbindgen/tests/expectations/tests/type_alias_template_specialized.rs

@@ -0,0 +1,7 @@
+#define foo "bar"
+#define CHAR 'b'
+#define CHARR '\0'
+#define FLOAT 5.09f
+#define FLOAT_EXPR (5 / 1000.0f)
+
+#define INVALID_UTF8 "\xf0\x28\x8c\x28"