Keep radix for integer literals in generated bindings

Author: miikkas

bindgen/clang.rs

@@ -5,6 +5,7 @@
 #![deny(clippy::missing_docs_in_private_items)]
 
 use crate::ir::context::BindgenContext;
+use crate::ir::var::LiteralRadix;
 use clang_sys::*;
 use std::cmp;
 
@@ -973,6 +974,33 @@ impl Cursor {
     pub(crate) fn is_inline_namespace(&self) -> bool {
         unsafe { clang_Cursor_isInlineNamespace(self.x) != 0 }
     }
+
+    /// Obtain the number base (radix) of a literal definition corresponding to the cursor.
+    ///
+    /// Returns `None` if unable to infer a base.
+    pub(crate) fn get_literal_radix(&self) -> Option<LiteralRadix> {
+        self.cexpr_tokens()
+            .iter()
+            .filter(|cexpr_token| {
+                cexpr_token.kind == cexpr::token::Kind::Literal
+            })
+            .find_map(|lit_tok| {
+                if lit_tok.raw.len() > 1 {
+                    match lit_tok.raw[0] {
+                        b'0' => match lit_tok.raw[1] {
+                            b'x' | b'X' => Some(LiteralRadix::Hexadecimal),
+                            b'b' | b'B' => Some(LiteralRadix::Binary),
+                            b'0'..=b'7' => Some(LiteralRadix::Octal),
+                            _ => None,
+                        },
+                        b'1'..=b'9' => Some(LiteralRadix::Decimal),
+                        _ => None,
+                    }
+                } else {
+                    Some(LiteralRadix::Decimal)
+                }
+            })
+    }
 }
 
 /// A struct that owns the tokenizer result from a given cursor.

bindgen/codegen/helpers.rs

@@ -139,6 +139,7 @@ pub(crate) mod ast_ty {
     use crate::ir::function::FunctionSig;
     use crate::ir::layout::Layout;
     use crate::ir::ty::{FloatKind, IntKind};
+    use crate::ir::var::LiteralRadix;
     use crate::RustTarget;
     use proc_macro2::TokenStream;
     use std::str::FromStr;
@@ -291,16 +292,70 @@ pub(crate) mod ast_ty {
         }
     }
 
-    pub(crate) fn int_expr(val: i64) -> TokenStream {
+    pub(crate) fn int_expr(
+        val: i64,
+        radix: Option<&LiteralRadix>,
+    ) -> TokenStream {
         // Don't use quote! { #val } because that adds the type suffix.
-        let val = proc_macro2::Literal::i64_unsuffixed(val);
-        quote!(#val)
+        let sign = if val.is_negative() { "-" } else { "" };
+        if let Some(radix) = radix {
+            match radix {
+                LiteralRadix::Decimal => {
+                    let val = proc_macro2::Literal::i64_unsuffixed(val);
+                    quote!(#val)
+                }
+                LiteralRadix::Binary => {
+                    let val = val.abs();
+                    let val = format!("{sign}0b{val:b}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+                LiteralRadix::Octal => {
+                    let val = val.abs();
+                    let val = format!("{sign}0o{val:o}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+                LiteralRadix::Hexadecimal => {
+                    let val = val.abs();
+                    let val = format!("{sign}0x{val:x}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+            }
+        } else {
+            // same as for Decimal
+            let val = proc_macro2::Literal::i64_unsuffixed(val);
+            quote!(#val)
+        }
     }
 
-    pub(crate) fn uint_expr(val: u64) -> TokenStream {
+    pub(crate) fn uint_expr(
+        val: u64,
+        radix: Option<&LiteralRadix>,
+    ) -> TokenStream {
         // Don't use quote! { #val } because that adds the type suffix.
-        let val = proc_macro2::Literal::u64_unsuffixed(val);
-        quote!(#val)
+        if let Some(radix) = radix {
+            match radix {
+                LiteralRadix::Decimal => {
+                    let val = proc_macro2::Literal::u64_unsuffixed(val);
+                    quote!(#val)
+                }
+                LiteralRadix::Binary => {
+                    let val = format!("0b{val:b}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+                LiteralRadix::Octal => {
+                    let val = format!("0o{val:o}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+                LiteralRadix::Hexadecimal => {
+                    let val = format!("0x{val:x}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+            }
+        } else {
+            // same as for Decimal
+            let val = proc_macro2::Literal::u64_unsuffixed(val);
+            quote!(#val)
+        }
     }
 
     pub(crate) fn cstr_expr(mut string: String) -> TokenStream {

bindgen/codegen/mod.rs

@@ -692,6 +692,7 @@ impl CodeGenerator for Var {
                     });
                 }
                 VarType::Int(val) => {
+                    let radix = self.radix();
                     let int_kind = var_ty
                         .into_resolver()
                         .through_type_aliases()
@@ -701,9 +702,9 @@ impl CodeGenerator for Var {
                         .as_integer()
                         .unwrap();
                     let val = if int_kind.is_signed() {
-                        helpers::ast_ty::int_expr(val)
+                        helpers::ast_ty::int_expr(val, radix)
                     } else {
-                        helpers::ast_ty::uint_expr(val as _)
+                        helpers::ast_ty::uint_expr(val as _, radix)
                     };
                     result.push(quote! {
                         #(#attrs)*
@@ -2438,7 +2439,7 @@ impl CodeGenerator for CompInfo {
             if let Some(explicit) = explicit_align {
                 // Ensure that the struct has the correct alignment even in
                 // presence of alignas.
-                let explicit = helpers::ast_ty::int_expr(explicit as i64);
+                let explicit = helpers::ast_ty::int_expr(explicit as i64, None);
                 attributes.push(quote! {
                     #[repr(align(#explicit))]
                 });
@@ -3384,11 +3385,15 @@ impl EnumBuilder {
         let is_rust_enum = self.is_rust_enum();
         let expr = match variant.val() {
             EnumVariantValue::Boolean(v) if is_rust_enum => {
-                helpers::ast_ty::uint_expr(u64::from(v))
+                helpers::ast_ty::uint_expr(u64::from(v), None)
             }
             EnumVariantValue::Boolean(v) => quote!(#v),
-            EnumVariantValue::Signed(v) => helpers::ast_ty::int_expr(v),
-            EnumVariantValue::Unsigned(v) => helpers::ast_ty::uint_expr(v),
+            EnumVariantValue::Signed(v) => {
+                helpers::ast_ty::int_expr(v, variant.radix())
+            }
+            EnumVariantValue::Unsigned(v) => {
+                helpers::ast_ty::uint_expr(v, variant.radix())
+            }
         };
 
         match self.kind {

bindgen/ir/enum_ty.rs

@@ -6,6 +6,7 @@ use super::item::Item;
 use super::ty::{Type, TypeKind};
 use crate::clang;
 use crate::ir::annotations::Annotations;
+use crate::ir::var::LiteralRadix;
 use crate::parse::ParseError;
 use crate::regex_set::RegexSet;
 
@@ -101,8 +102,11 @@ impl Enum {
                 } else {
                     cursor.enum_val_unsigned().map(EnumVariantValue::Unsigned)
                 };
+
                 if let Some(val) = value {
                     let name = cursor.spelling();
+
+                    let radix = cursor.get_literal_radix();
                     let annotations = Annotations::new(&cursor);
                     let custom_behavior = ctx
                         .options()
@@ -142,6 +146,7 @@ impl Enum {
                         comment,
                         val,
                         custom_behavior,
+                        radix,
                     ));
                 }
             }
@@ -254,6 +259,9 @@ pub(crate) struct EnumVariant {
 
     /// The custom behavior this variant may have, if any.
     custom_behavior: Option<EnumVariantCustomBehavior>,
+
+    /// The radix of the literal value of the variant.
+    radix: Option<LiteralRadix>,
 }
 
 /// A constant value assigned to an enumeration variant.
@@ -277,13 +285,15 @@ impl EnumVariant {
         comment: Option<String>,
         val: EnumVariantValue,
         custom_behavior: Option<EnumVariantCustomBehavior>,
+        radix: Option<LiteralRadix>,
     ) -> Self {
         EnumVariant {
             name,
             name_for_allowlisting,
             comment,
             val,
             custom_behavior,
+            radix,
         }
     }
 
@@ -302,6 +312,11 @@ impl EnumVariant {
         self.val
     }
 
+    /// Get this variant's radix.
+    pub(crate) fn radix(&self) -> Option<&LiteralRadix> {
+        self.radix.as_ref()
+    }
+
     /// Get this variant's documentation.
     pub(crate) fn comment(&self) -> Option<&str> {
         self.comment.as_deref()

bindgen/ir/var.rs

@@ -30,6 +30,19 @@ pub(crate) enum VarType {
     String(Vec<u8>),
 }
 
+/// Integer literal's radix.
+#[derive(Debug)]
+pub(crate) enum LiteralRadix {
+    /// Binary (base 2).
+    Binary,
+    /// Octal (base 8).
+    Octal,
+    /// Decimal (base 10).
+    Decimal,
+    /// Hexadecimal (base 16).
+    Hexadecimal,
+}
+
 /// A `Var` is our intermediate representation of a variable.
 #[derive(Debug)]
 pub(crate) struct Var {
@@ -45,6 +58,8 @@ pub(crate) struct Var {
     val: Option<VarType>,
     /// Whether this variable is const.
     is_const: bool,
+    /// The radix of the variable, if integer.
+    radix: Option<LiteralRadix>,
 }
 
 impl Var {
@@ -56,18 +71,26 @@ impl Var {
         ty: TypeId,
         val: Option<VarType>,
         is_const: bool,
+        radix: Option<LiteralRadix>,
     ) -> Var {
         assert!(!name.is_empty());
+
         Var {
             name,
             mangled_name,
             link_name,
             ty,
             val,
             is_const,
+            radix,
         }
     }
 
+    /// The radix of this integer variable, if any.
+    pub(crate) fn radix(&self) -> Option<&LiteralRadix> {
+        self.radix.as_ref()
+    }
+
     /// Is this variable `const` qualified?
     pub(crate) fn is_const(&self) -> bool {
         self.is_const
@@ -180,6 +203,7 @@ impl ClangSubItemParser for Var {
         use cexpr::expr::EvalResult;
         use cexpr::literal::CChar;
         use clang_sys::*;
+
         match cursor.kind() {
             CXCursor_MacroDefinition => {
                 for callbacks in &ctx.options().parse_callbacks {
@@ -198,6 +222,7 @@ impl ClangSubItemParser for Var {
                 }
 
                 let value = parse_macro(ctx, &cursor);
+                let radix = cursor.get_literal_radix();
 
                 let Some((id, value)) = value else {
                     return Err(ParseError::Continue);
@@ -265,7 +290,7 @@ impl ClangSubItemParser for Var {
                 let ty = Item::builtin_type(type_kind, true, ctx);
 
                 Ok(ParseResult::New(
-                    Var::new(name, None, None, ty, Some(val), true),
+                    Var::new(name, None, None, ty, Some(val), true, radix),
                     Some(cursor),
                 ))
             }
@@ -334,39 +359,52 @@ impl ClangSubItemParser for Var {
                 // 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 {
+                let (value, radix) = if is_integer {
                     let TypeKind::Int(kind) = *canonical_ty.unwrap().kind()
                     else {
                         unreachable!()
                     };
 
                     let mut val = cursor.evaluate().and_then(|v| v.as_int());
+
+                    let radix = cursor.get_literal_radix();
+
                     if val.is_none() || !kind.signedness_matches(val.unwrap()) {
                         val = get_integer_literal_from_cursor(&cursor);
                     }
 
-                    val.map(|val| {
-                        if kind == IntKind::Bool {
-                            VarType::Bool(val != 0)
-                        } else {
-                            VarType::Int(val)
-                        }
-                    })
+                    (
+                        val.map(|val| {
+                            if kind == IntKind::Bool {
+                                VarType::Bool(val != 0)
+                            } else {
+                                VarType::Int(val)
+                            }
+                        }),
+                        radix,
+                    )
                 } else if is_float {
-                    cursor
-                        .evaluate()
-                        .and_then(|v| v.as_double())
-                        .map(VarType::Float)
+                    (
+                        cursor
+                            .evaluate()
+                            .and_then(|v| v.as_double())
+                            .map(VarType::Float),
+                        None,
+                    )
                 } else {
-                    cursor
-                        .evaluate()
-                        .and_then(|v| v.as_literal_string())
-                        .map(VarType::String)
+                    (
+                        cursor
+                            .evaluate()
+                            .and_then(|v| v.as_literal_string())
+                            .map(VarType::String),
+                        None,
+                    )
                 };
 
                 let mangling = cursor_mangling(ctx, &cursor);
-                let var =
-                    Var::new(name, mangling, link_name, ty, value, is_const);
+                let var = Var::new(
+                    name, mangling, link_name, ty, value, is_const, radix,
+                );
 
                 Ok(ParseResult::New(var, Some(cursor)))
             }