Improve constant generation (float, chars), write docs for it.

Author: emilio

libbindgen/src/clang.rs

@@ -1265,36 +1265,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

@@ -150,4 +150,11 @@ pub mod ast_ty {
         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 interned_str = f.to_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

@@ -323,23 +323,36 @@ impl CodeGenerator for Var {
                         .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(ty)
+                                .build(quote_ty!(ctx.ext_cx(), &'static $ty))
                         }
                         Err(..) => {
-                            // Account the trailing zero.
-                            let len = bytes.len() + 1;
-                            let ty = quote_ty!(ctx.ext_cx(), [u8; $len]);
-
                             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);

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,11 +8,13 @@ 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::{TypeKind, FloatKind};
 
 #[derive(Debug)]
 pub enum VarType {
     Int(i64),
+    Float(f64),
+    Char(u8),
     String(Vec<u8>),
 }
 
@@ -81,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());
@@ -111,11 +114,24 @@ impl ClangSubItemParser for Var {
                 // this point.
                 let name = String::from_utf8(id).unwrap();
                 let (type_kind, val) = match value {
-                    // TODO(emilio): Handle the non-invalid ones!
-                    EvalResult::Float(..) |
-                    EvalResult::Char(..) |
                     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),
@@ -169,13 +185,16 @@ impl ClangSubItemParser for Var {
                 // tests/headers/inner_const.hpp
                 //
                 // That's fine because in that case we know it's not a literal.
-                //
-                // TODO: Strings, stuff like that.
-                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()
@@ -184,14 +203,17 @@ 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)))
             }
             _ => {

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;

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/macro_str.rs

@@ -5,3 +5,6 @@ enum {
 };
 
 const long long BAZ = (1 << foo) | bar;
+const double fuzz = (1 + 50.0f);
+const char BAZZ = '5';
+const char WAT = '\0';

tests/headers/constant-evaluate.h

@@ -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"