From 8270a0ca766ea834032daeb67c7f32a1947ab3bd Mon Sep 17 00:00:00 2001
From: Jeff Waugh <jdub@bethesignal.org>
Date: Tue, 15 Nov 2016 14:37:20 +1100
Subject: Transition to libbindgen sub-crate

- The root crate is the `bindgen` binary
- Rust-ify the test suite, no more subprocesses!
- Update Travis config to test both crates
---
 libbindgen/src/codegen/helpers.rs | 135 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 135 insertions(+)
 create mode 100644 libbindgen/src/codegen/helpers.rs

(limited to 'libbindgen/src/codegen/helpers.rs')

diff --git a/libbindgen/src/codegen/helpers.rs b/libbindgen/src/codegen/helpers.rs
new file mode 100644
index 00000000..6e5a6f0e
--- /dev/null
+++ b/libbindgen/src/codegen/helpers.rs
@@ -0,0 +1,135 @@
+//! Helpers for code generation that don't need macro expansion.
+
+use aster;
+use ir::layout::Layout;
+use syntax::ast;
+use syntax::ptr::P;
+
+
+pub mod attributes {
+    use aster;
+    use syntax::ast;
+
+    pub fn repr(which: &str) -> ast::Attribute {
+        aster::AstBuilder::new().attr().list("repr").words(&[which]).build()
+    }
+
+    pub fn repr_list(which_ones: &[&str]) -> ast::Attribute {
+        aster::AstBuilder::new().attr().list("repr").words(which_ones).build()
+    }
+
+    pub fn derives(which_ones: &[&str]) -> ast::Attribute {
+        aster::AstBuilder::new().attr().list("derive").words(which_ones).build()
+    }
+
+    pub fn inline() -> ast::Attribute {
+        aster::AstBuilder::new().attr().word("inline")
+    }
+
+    pub fn doc(comment: &str) -> ast::Attribute {
+        aster::AstBuilder::new().attr().doc(comment)
+    }
+
+    pub fn link_name(name: &str) -> ast::Attribute {
+        aster::AstBuilder::new().attr().name_value("link_name").str(name)
+    }
+}
+
+/// Generates a proper type for a field or type with a given `Layout`, that is,
+/// a type with the correct size and alignment restrictions.
+pub struct BlobTyBuilder {
+    layout: Layout,
+}
+
+impl BlobTyBuilder {
+    pub fn new(layout: Layout) -> Self {
+        BlobTyBuilder {
+            layout: layout,
+        }
+    }
+
+    pub fn build(self) -> P<ast::Ty> {
+        use std::cmp;
+
+        let ty_name = match self.layout.align {
+            8 => "u64",
+            4 => "u32",
+            2 => "u16",
+            1 | _ => "u8",
+        };
+        let data_len = if ty_name == "u8" {
+            self.layout.size
+        } else {
+            self.layout.size / cmp::max(self.layout.align, 1)
+        };
+
+        let inner_ty = aster::AstBuilder::new().ty().path().id(ty_name).build();
+        if data_len == 1 {
+            inner_ty
+        } else {
+            aster::ty::TyBuilder::new().array(data_len).build(inner_ty)
+        }
+    }
+}
+
+pub mod ast_ty {
+    use aster;
+    use ir::context::BindgenContext;
+    use ir::ty::FloatKind;
+    use syntax::ast;
+    use syntax::ptr::P;
+
+    pub fn raw_type(ctx: &BindgenContext, name: &str) -> P<ast::Ty> {
+        let ident = ctx.rust_ident_raw(&name);
+        match ctx.options().ctypes_prefix {
+            Some(ref prefix) => {
+                let prefix = ctx.rust_ident_raw(prefix);
+                quote_ty!(ctx.ext_cx(), $prefix::$ident)
+            }
+            None => quote_ty!(ctx.ext_cx(), ::std::os::raw::$ident),
+        }
+    }
+
+    pub fn float_kind_rust_type(ctx: &BindgenContext,
+                                fk: FloatKind)
+                                -> P<ast::Ty> {
+        macro_rules! raw {
+            ($ty: ident) => {
+                raw_type(ctx, stringify!($ty))
+            }
+        }
+        // TODO: we probably should just take the type layout into
+        // account?
+        //
+        // Also, maybe this one shouldn't be the default?
+        //
+        // FIXME: `c_longdouble` doesn't seem to be defined in some
+        // systems, so we use `c_double` directly.
+        match (fk, ctx.options().convert_floats) {
+            (FloatKind::Float, true) => aster::ty::TyBuilder::new().f32(),
+            (FloatKind::Double, true) |
+            (FloatKind::LongDouble, true) => aster::ty::TyBuilder::new().f64(),
+            (FloatKind::Float, false) => raw!(c_float),
+            (FloatKind::Double, false) |
+            (FloatKind::LongDouble, false) => raw!(c_double),
+            (FloatKind::Float128, _) => {
+                aster::ty::TyBuilder::new().array(16).u8()
+            }
+        }
+    }
+
+    pub fn int_expr(val: i64) -> P<ast::Expr> {
+        use std::i64;
+        let expr = aster::AstBuilder::new().expr();
+
+        // This is not representable as an i64 if it's negative, so we
+        // special-case it.
+        //
+        // Fix in aster incoming.
+        if val == i64::MIN {
+            expr.neg().uint(1u64 << 63)
+        } else {
+            expr.int(val)
+        }
+    }
+}
-- 
cgit v1.2.3