Keep radix for integer literals in generated bindings

Author: miikkas

bindgen-tests/tests/expectations/tests/different_radix_literals.rs

@@ -0,0 +1,70 @@
+// bindgen-flags: -- -std=c++14
+// (C23 is not available in clang 9.0, but C++14 supports the same literals)
+
+// Binary integer literals (C23) - 0b10 is 2 in decimal
+
+#define DEFINE_BIN_LITERAL 0b10
+#define DEFINE_NEG_BIN_LITERAL -0b10
+const int CONST_INT_BIN_LITERAL = 0b10;
+const int CONST_INT_NEG_BIN_LITERAL = -0b10;
+
+// Octal integer literals - 010 is 8 in decimal
+
+#define DEFINE_OCT_LITERAL 010
+#define DEFINE_NEG_OCT_LITERAL -010
+const int CONST_INT_OCT_LITERAL = 010;
+const int CONST_INT_NEG_OCT_LITERAL = -010;
+
+// Hexadecimal integer literals - 0x10 is 16 in decimal
+
+#define DEFINE_HEX_LITERAL 0x10
+#define DEFINE_NEG_HEX_LITERAL -0x10
+const int CONST_INT_HEX_LITERAL = 0x10;
+const int CONST_INT_NEG_HEX_LITERAL = -0x10;
+
+// Default decimal integer literals - 10 is 10 in decimal
+
+#define DEFINE_DEC_LITERAL 10
+#define DEFINE_NEG_DEC_LITERAL -10
+const int CONST_INT_DEC_LITERAL = 10;
+const int CONST_INT_NEG_DEC_LITERAL = -10;
+
+// Enums with binary, octal, and hexadecimal integer literals
+
+enum MultiRadixLiteral {
+    ENUM_BIN_LITERAL = 0b10,
+    ENUM_NEG_BIN_LITERAL = -0b10,
+    ENUM_OCT_LITERAL = 010,
+    ENUM_NEG_OCT_LITERAL = -010,
+    ENUM_HEX_LITERAL = 0x10,
+    ENUM_NEG_HEX_LITERAL = -0x10,
+    ENUM_DEC_LITERAL = 10,
+    ENUM_NEG_DEC_LITERAL = -10,
+};
+
+// Edge cases: minimum i64s
+
+const long long MIN_I64_BIN = -0b1000000000000000000000000000000000000000000000000000000000000000;
+const long long MIN_I64_OCT = -01000000000000000000000;
+const long long MIN_I64_DEC = -9223372036854775808;
+const long long MIN_I64_HEX = -0x8000000000000000;
+
+// Big B or big X
+
+const int BIG_B_BIN = 0B1;
+const int BIG_X_HEX = 0XF;
+
+// Octal with extra leading zero
+
+const char AGENT = 007;
+
+// C23 and C++14 thousands'/digit separator '
+
+const unsigned long long SEP_BIN = 0b11111111'00000000;
+const unsigned long long SEP_OCT = 07777'7777'7777;
+const unsigned long long SEP_DEC = 299'792'458;
+const unsigned long long SEP_HEX = 0x1111'bbbb'cccc'dddd;
+
+// Multiple declarations
+
+const long BIN_1ST = 0b10101010, OCT_2ND = 0777, DEC_3RD = 1234, HEX_4TH = 0xffff;

bindgen-tests/tests/headers/different_radix_literals.hpp

@@ -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,55 @@ impl Cursor {
     pub(crate) fn is_inline_namespace(&self) -> bool {
         unsafe { clang_Cursor_isInlineNamespace(self.x) != 0 }
     }
+
+    /// Obtain the number base (radix) of an integer literal definition corresponding to the cursor.
+    ///
+    /// Returns `None` if unable to infer a base.
+    pub(crate) fn get_literal_radix(&self) -> Option<LiteralRadix> {
+        self.tokens().iter().find_map(|token| {
+            if token.kind == CXToken_Literal {
+                LiteralRadix::from_integer_literal_token(token.spelling())
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Obtain the number base (radix) of an integer literal definition corresponding to the cursor,
+    /// ensuring that the radix is from the literal following a given identifier in the list of
+    /// tokens.
+    ///
+    /// Returns `None` if unable to infer a base.
+    pub(crate) fn get_literal_radix_of_identifier(
+        &self,
+        identifier: &str,
+    ) -> Option<LiteralRadix> {
+        self.tokens()
+            .iter()
+            .scan(false, |identifier_found, token| {
+                if *identifier_found {
+                    Some((true, token))
+                } else if token.kind == CXToken_Identifier {
+                    if token.spelling() == identifier.as_bytes() {
+                        *identifier_found = true;
+                        Some((*identifier_found, token))
+                    } else {
+                        Some((*identifier_found, token))
+                    }
+                } else {
+                    Some((*identifier_found, token))
+                }
+            })
+            .find_map(|(identifier_found, token)| {
+                if !identifier_found {
+                    None
+                } else if token.kind == CXToken_Literal {
+                    LiteralRadix::from_integer_literal_token(token.spelling())
+                } else {
+                    None
+                }
+            })
+    }
 }
 
 /// A struct that owns the tokenizer result from a given cursor.

bindgen/clang.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.unsigned_abs();
+                    let val = format!("{sign}0b{val:b}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+                LiteralRadix::Octal => {
+                    let val = val.unsigned_abs();
+                    let val = format!("{sign}0o{val:o}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+                LiteralRadix::Hexadecimal => {
+                    let val = val.unsigned_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/helpers.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/codegen/mod.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,10 @@ 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 +145,7 @@ impl Enum {
                         comment,
                         val,
                         custom_behavior,
+                        radix,
                     ));
                 }
             }
@@ -254,6 +258,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 +284,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 +311,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()