Generate macro string constants.

Signed-off-by: Emilio Cobos Álvarez <ecoal95@gmail.com>

Author: emilio

src/codegen/helpers.rs

@@ -132,4 +132,22 @@ 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))
+    }
 }

src/codegen/mod.rs

@@ -299,6 +299,8 @@ impl CodeGenerator for Var {
                ctx: &BindgenContext,
                result: &mut CodegenResult,
                item: &Item) {
+        use ir::var::VarType;
+
         let canonical_name = item.canonical_name(ctx);
 
         if result.seen_var(&canonical_name) {
@@ -313,10 +315,34 @@ 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) => {
+                    match String::from_utf8(bytes.clone()) {
+                        Ok(string) => {
+                            const_item
+                                .build(helpers::ast_ty::cstr_expr(string))
+                                .build(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)
+                        }
+                    }
+                }
+            };
+
+            result.push(item);
         } else {
             let mut attrs = vec![];
             if let Some(mangled) = self.mangled_name() {

src/ir/var.rs

@@ -10,6 +10,12 @@ use super::int::IntKind;
 use super::item::{Item, ItemId};
 use super::ty::TypeKind;
 
+#[derive(Debug)]
+pub enum VarType {
+    Int(i64),
+    String(Vec<u8>),
+}
+
 /// A `Var` is our intermediate representation of a variable.
 #[derive(Debug)]
 pub struct Var {
@@ -19,9 +25,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 +36,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 +55,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.
@@ -105,13 +110,18 @@ 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 {
+                let (type_kind, val) = match value {
                     // TODO(emilio): Handle the non-invalid ones!
                     EvalResult::Float(..) |
                     EvalResult::Char(..) |
-                    EvalResult::Str(..) |
                     EvalResult::Invalid => return Err(ParseError::Continue),
 
+                    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 +141,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,6 +169,8 @@ 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())
@@ -171,7 +183,7 @@ impl ClangSubItemParser for Var {
                         .or_else(|| {
                             let tu = ctx.translation_unit();
                             get_integer_literal_from_cursor(&cursor, tu)
-                        })
+                        }).map(VarType::Int)
                 } else {
                     None
                 };
@@ -181,7 +193,6 @@ impl ClangSubItemParser for Var {
 
                 let var = Var::new(name, mangling, ty, value, is_const);
                 Ok(ParseResult::New(var, Some(cursor)))
-
             }
             _ => {
                 /* TODO */

tests/expectations/tests/macro_str.rs

@@ -0,0 +1,8 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+pub const foo: *const u8 = b"bar\x00";
+pub const BOO: [u8; 5usize] = [240, 40, 140, 40, 0];

tests/headers/macro_str.h

@@ -0,0 +1,3 @@
+#define foo "bar"
+
+#define BOO "\xf0\x28\x8c\x28"