Merge pull request rust-lang#280 from nox/rust-enums

Introduce -no-rust-enums (fixes rust-lang#276)

Author: nox

src/bin/bindgen.rs

@@ -97,6 +97,10 @@ fn parse_args(args: &[String]) -> ParseResult {
                     options.builtins = true;
                     ix += 1;
                 }
+                "-no-rust-enums" => {
+                    options.rust_enums = false;
+                    ix += 1;
+                }
                 "-allow-unknown-types" => {
                     options.fail_on_unknown_type = false;
                     ix += 1;

src/gen.rs

@@ -20,7 +20,7 @@ use syntax::attr::mk_attr_id;
 use syntax::ptr::P;
 use syntax::print::pprust::tts_to_string;
 
-use super::LinkType;
+use super::{BindgenOptions, LinkType};
 use types::*;
 
 struct GenCtx<'r> {
@@ -115,7 +115,11 @@ fn enum_name(name: &str) -> String {
     format!("Enum_{}", name)
 }
 
-pub fn gen_mod(links: &[(String, LinkType)], globs: Vec<Global>, span: Span) -> Vec<P<ast::Item>> {
+pub fn gen_mod(
+        options: &BindgenOptions,
+        globs: Vec<Global>,
+        span: Span)
+        -> Vec<P<ast::Item>> {
     // Create a dummy ExtCtxt. We only need this for string interning and that uses TLS.
     let mut features = Features::new();
     features.allow_quote = true;
@@ -180,8 +184,11 @@ pub fn gen_mod(links: &[(String, LinkType)], globs: Vec<Global>, span: Span) ->
     for g in gs.into_iter() {
         match g {
             GType(ti) => {
-                let t = ti.borrow().clone();
-                defs.extend(ctypedef_to_rs(&mut ctx, t.name.clone(), &t.ty).into_iter())
+                let t = ti.borrow();
+                defs.extend(ctypedef_to_rs(
+                    &mut ctx,
+                    options.rust_enums,
+                    t.name.clone(), &t.ty))
             },
             GCompDecl(ci) => {
                 {
@@ -214,7 +221,10 @@ pub fn gen_mod(links: &[(String, LinkType)], globs: Vec<Global>, span: Span) ->
                     e.name = unnamed_name(&mut ctx, e.name.clone());
                 }
                 let e = ei.borrow();
-                defs.extend(cenum_to_rs(&mut ctx, enum_name(&e.name), e.kind, e.layout, &e.items).into_iter())
+                defs.extend(cenum_to_rs(
+                    &mut ctx,
+                    options.rust_enums,
+                    enum_name(&e.name), e.kind, e.layout, &e.items));
             },
             GVar(vi) => {
                 let v = vi.borrow();
@@ -269,11 +279,11 @@ pub fn gen_mod(links: &[(String, LinkType)], globs: Vec<Global>, span: Span) ->
     };
 
     if !Vec::is_empty(&vars) {
-        defs.push(mk_extern(&mut ctx, links, vars, abi::Abi::C));
+        defs.push(mk_extern(&mut ctx, &options.links, vars, abi::Abi::C));
     }
 
     for (abi, funcs) in funcs.into_iter() {
-        defs.push(mk_extern(&mut ctx, links, funcs, abi));
+        defs.push(mk_extern(&mut ctx, &options.links, funcs, abi));
     }
 
     //let attrs = vec!(mk_attr_list(&mut ctx, "allow", ["dead_code", "non_camel_case_types", "uppercase_variables"]));
@@ -439,7 +449,12 @@ fn tag_dup_decl(gs: Vec<Global>) -> Vec<Global> {
     res
 }
 
-fn ctypedef_to_rs(ctx: &mut GenCtx, name: String, ty: &Type) -> Vec<P<ast::Item>> {
+fn ctypedef_to_rs(
+        ctx: &mut GenCtx,
+        rust_enums: bool,
+        name: String,
+        ty: &Type)
+        -> Vec<P<ast::Item>> {
     fn mk_item(ctx: &mut GenCtx, name: String, ty: &Type) -> P<ast::Item> {
         let rust_name = rust_type_id(ctx, name);
         let rust_ty = cty_to_rs(ctx, ty);
@@ -478,7 +493,7 @@ fn ctypedef_to_rs(ctx: &mut GenCtx, name: String, ty: &Type) -> Vec<P<ast::Item>
             if is_empty {
                 ei.borrow_mut().name = name.clone();
                 let e = ei.borrow();
-                cenum_to_rs(ctx, name, e.kind, e.layout, &e.items)
+                cenum_to_rs(ctx, rust_enums, name, e.kind, e.layout, &e.items)
             } else {
                 vec!(mk_item(ctx, name, ty))
             }
@@ -700,22 +715,6 @@ fn const_to_rs(ctx: &mut GenCtx, name: String, val: i64, val_ty: ast::Ty) -> P<a
     })
 }
 
-fn enum_kind_is_signed(kind: IKind) -> bool {
-    match kind {
-        IBool => false,
-        ISChar => true,
-        IUChar => false,
-        IShort => true,
-        IUShort => false,
-        IInt => true,
-        IUInt => false,
-        ILong => true,
-        IULong => false,
-        ILongLong => true,
-        IULongLong => false,
-    }
-}
-
 fn enum_size_to_rust_type_name(signed: bool, size: usize) -> &'static str {
     match (signed, size) {
         (true, 1) => "i8",
@@ -765,20 +764,41 @@ fn cenum_value_to_int_lit(
     }
 }
 
-
-fn cenum_to_rs(ctx: &mut GenCtx,
-               name: String,
-               kind: IKind,
-               layout: Layout,
-               enum_items: &[EnumItem])
-               -> Vec<P<ast::Item>> {
+fn cenum_to_rs(
+       ctx: &mut GenCtx,
+       rust_enums: bool,
+       name: String,
+       kind: IKind,
+       layout: Layout,
+       enum_items: &[EnumItem])
+       -> Vec<P<ast::Item>> {
     let enum_name = ctx.ext_cx.ident_of(&name);
     let enum_ty = ctx.ext_cx.ty_ident(ctx.span, enum_name);
-    let enum_is_signed = enum_kind_is_signed(kind);
+    let enum_is_signed = kind.is_signed();
+    let enum_repr = enum_size_to_rust_type_name(enum_is_signed, layout.size);
+    let mut items = vec![];
+
+    if !rust_enums {
+        items.push(ctx.ext_cx.item_ty(
+            ctx.span,
+            enum_name,
+            ctx.ext_cx.ty_ident(
+                ctx.span,
+                ctx.ext_cx.ident_of(enum_repr))));
+        for item in enum_items {
+            let value = cenum_value_to_int_lit(
+                ctx, enum_is_signed, layout.size, item.val);
+            items.push(ctx.ext_cx.item_const(
+                ctx.span,
+                ctx.ext_cx.ident_of(&item.name),
+                enum_ty.clone(),
+                value));
+        }
+        return items;
+    }
 
     let mut variants = vec![];
     let mut found_values = HashMap::new();
-    let mut items = vec![];
 
     for item in enum_items {
         let name = ctx.ext_cx.ident_of(&item.name);
@@ -810,7 +830,7 @@ fn cenum_to_rs(ctx: &mut GenCtx,
         }));
     }
 
-    let enum_repr = InternedString::new(enum_size_to_rust_type_name(enum_is_signed, layout.size));
+    let enum_repr = InternedString::new(enum_repr);
 
     let repr_arg = ctx.ext_cx.meta_word(ctx.span, enum_repr);
     let repr_list = ctx.ext_cx.meta_list(ctx.span, InternedString::new("repr"), vec![repr_arg]);

src/lib.rs

@@ -76,6 +76,11 @@ impl<'a> Builder<'a> {
         self
     }
 
+    pub fn rust_enums(&mut self, value: bool) -> &mut Self {
+        self.options.rust_enums = value;
+        self
+    }
+
     pub fn log(&mut self, logger: &'a Logger) -> &mut Self {
         self.logger = Some(logger);
         self
@@ -100,6 +105,7 @@ impl<'a> Default for Builder<'a> {
 pub struct BindgenOptions {
     pub match_pat: Vec<String>,
     pub builtins: bool,
+    pub rust_enums: bool,
     pub links: Vec<(String, LinkType)>,
     pub emit_ast: bool,
     pub fail_on_unknown_type: bool,
@@ -112,6 +118,7 @@ impl Default for BindgenOptions {
         BindgenOptions {
             match_pat: Vec::new(),
             builtins: false,
+            rust_enums: true,
             links: Vec::new(),
             emit_ast: false,
             fail_on_unknown_type: false,
@@ -159,7 +166,7 @@ impl Bindings {
 
         let module = ast::Mod {
             inner: span,
-            items: gen::gen_mod(&options.links[..], globals, span)
+            items: gen::gen_mod(options, globals, span)
         };
 
         Ok(Bindings {

src/types.rs

@@ -174,6 +174,24 @@ pub enum IKind {
     IULongLong
 }
 
+impl IKind {
+    pub fn is_signed(self) -> bool {
+        match self {
+            IBool => false,
+            ISChar => true,
+            IUChar => false,
+            IShort => true,
+            IUShort => false,
+            IInt => true,
+            IUInt => false,
+            ILong => true,
+            IULong => false,
+            ILongLong => true,
+            IULongLong => false,
+        }
+    }
+}
+
 #[derive(Copy, Clone, PartialEq)]
 pub enum FKind {
     FFloat,

tests/support.rs

@@ -1,8 +1,6 @@
 use bindgen;
 use bindgen::{Logger, BindgenOptions};
 
-use std::default::Default;
-
 use syntax::ast;
 use syntax::codemap;
 use syntax::codemap::DUMMY_SP;
@@ -23,8 +21,9 @@ impl Logger for TestLogger {
     }
 }
 
-pub fn generate_bindings(filename: &str) -> Result<Vec<P<ast::Item>>, ()> {
-    let mut options:BindgenOptions = Default::default();
+pub fn generate_bindings(mut options: BindgenOptions,
+                         filename: &str)
+                         -> Result<Vec<P<ast::Item>>, ()> {
     if filename.ends_with("hpp") {
         options.clang_args.push("-std=c++11".to_string());
         options.clang_args.push("-Wno-narrowing".to_string());
@@ -35,10 +34,12 @@ pub fn generate_bindings(filename: &str) -> Result<Vec<P<ast::Item>>, ()> {
     Ok(try!(bindgen::Bindings::generate(&options, Some(&logger as &Logger), None)).into_ast())
 }
 
-pub fn assert_bind_eq(filename: &str, reference_items_str: &str)
-{
+pub fn assert_bind_eq(options: BindgenOptions,
+                      filename: &str,
+                      reference_items_str: &str) {
     let ext_cx = mk_dummy_ext_ctxt();
-    let generated_items = generate_bindings(&format!("tests/{}", filename)[..]).unwrap();
+    let generated_items =
+        generate_bindings(options, &format!("tests/{}", filename)[..]).unwrap();
 
     let mut parser = parse::new_parser_from_source_str(ext_cx.parse_sess(), ext_cx.cfg(), "".to_string(), reference_items_str.to_string());
     let mut reference_items = Vec::new();

tests/test_decl.rs

@@ -2,7 +2,7 @@ use support::assert_bind_eq;
 
 #[test]
 fn ptr_to_array() {
-    assert_bind_eq("headers/decl_ptr_to_array.h", "
+    assert_bind_eq(Default::default(), "headers/decl_ptr_to_array.h", "
         extern \"C\" {
             pub static mut foo: [::std::os::raw::c_int; 1usize];
         }