Keep radix for integer literals in generated bindings

Author: miikkas

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

@@ -0,0 +1,77 @@
+// 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;
+
+// Smaller integer types
+
+const unsigned short USHORT_HEX = 0xFFFF;
+const short SHORT_HEX = 0x7FFF;
+const unsigned char UCHAR_HEX = 0xFF;
+const char CHAR_HEX = 0x7F;

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,48 @@ 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 token.kind == CXToken_Identifier &&
+                    token.spelling() == identifier.as_bytes()
+                {
+                    *identifier_found = true;
+                }
+                Some((*identifier_found, token))
+            })
+            .find_map(|(identifier_found, token)| {
+                if identifier_found && token.kind == CXToken_Literal {
+                    LiteralRadix::from_integer_literal_token(token.spelling())
+                } else {
+                    None
+                }
+            })
+    }
 }
 
 /// A struct that owns the tokenizer result from a given cursor.