add: added new header-file with type-definitions (def.h) + additional callback

HunkBenny · HunkBenny · commit 87540b13006f · 2025-12-12T09:46:05.000+01:00
The new callback is needed because bindgen cannot infer type-casted macros. For example the macro '#define SCIP_INVALID (double)1e99' is too complicated. This is because of the type-cast to double. If we simply remove the (double), then bindgen CAN generate a binding for it. It also defaults to an `f64` in Rust, which is what the C-representation would look like too. The callback should only be used for types of which we know that Rust can infer the datatype. Therefore, I made sure that it only goes off on;
1. macros that the user deliberately targets (added via `target`-method)
2. only looks at casts to clang-keywords. So no weird custom mumbo-jumbo casts
diff --git a/build.rs b/build.rs
@@ -1,4 +1,5 @@
 mod bundled;
+mod callback;
 mod from_source;
 
 #[cfg(any(feature = "bundled", feature = "from-source"))]
@@ -13,6 +14,7 @@ use std::path::PathBuf;
 
 use crate::from_source::{compile_scip, download_scip_source, is_from_source_feature_enabled};
 use bundled::*;
+use callback::DeriveCastedConstant;
 
 #[cfg(not(feature = "bundled"))]
 pub fn is_bundled_feature_enabled() -> bool {
@@ -60,10 +62,18 @@ fn _build_from_scip_dir(path: &str) -> bindgen::Builder {
         .to_str()
         .unwrap()
         .to_owned();
+    let scipdef_file = PathBuf::from(&path)
+        .join("include")
+        .join("scip")
+        .join("def.h")
+        .to_str()
+        .unwrap()
+        .to_owned();
 
     bindgen::Builder::default()
         .header(scip_header_file)
         .header(scipdefplugins_header_file)
+        .header(scipdef_file)
         .parse_callbacks(Box::new(bindgen::CargoCallbacks))
         .clang_arg(format!("-I{}", include_dir_path))
 }
@@ -100,9 +110,9 @@ fn try_system_include_paths() -> Option<bindgen::Builder> {
     let search_paths = vec![
         "/usr/include",
         "/usr/local/include",
-        "/opt/local/include",           // MacPorts
-        "/opt/homebrew/include",         // Homebrew ARM Mac
-        "/usr/local/opt/scip/include",  // Homebrew Intel Mac
+        "/opt/local/include",          // MacPorts
+        "/opt/homebrew/include",       // Homebrew ARM Mac
+        "/usr/local/opt/scip/include", // Homebrew Intel Mac
     ];
 
     for base_path in search_paths {
@@ -118,7 +128,7 @@ fn try_system_include_paths() -> Option<bindgen::Builder> {
                     .header(scip_h.to_str().unwrap())
                     .header(scipdefplugins_h.to_str().unwrap())
                     .parse_callbacks(Box::new(bindgen::CargoCallbacks))
-                    .clang_arg(format!("-I{}", base_path))
+                    .clang_arg(format!("-I{}", base_path)),
             );
         }
     }
@@ -188,14 +198,17 @@ fn main() -> Result<(), Box<dyn Error>> {
             println!("cargo:rustc-link-lib=soplex");
         }
     }
+    // Setup the DeriveCastedConstant callback to target SCIP_INVALID
+    let derive_casted_constant = DeriveCastedConstant::new().target("SCIP_INVALID");
 
     let builder = builder
         .blocklist_item("FP_NAN")
         .blocklist_item("FP_INFINITE")
         .blocklist_item("FP_ZERO")
         .blocklist_item("FP_SUBNORMAL")
         .blocklist_item("FP_NORMAL")
-        .parse_callbacks(Box::new(bindgen::CargoCallbacks));
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks))
+        .parse_callbacks(Box::new(derive_casted_constant));
 
     let bindings = builder.generate()?;
     let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
diff --git a/callback.rs b/callback.rs
@@ -0,0 +1,61 @@
+//! This file contains some custom callbacks for bindgen.
+
+use bindgen::callbacks::{IntKind, Token, TokenKind};
+use std::collections::HashSet;
+
+/// This callback will be used to remove the type casts.
+/// bindgen has a hard time parsing constants with type casts like
+/// ```rust
+/// #define SCIP_INVALID (double)1e99
+/// ```
+///
+/// ### Note;
+/// Maybe we should be careful on which macros we use this? I can see a situation where Rust and C
+/// would have different opinions on what the macro should look like.
+#[derive(Debug)]
+pub struct DeriveCastedConstant {
+    /// Set of macros to target for removing type casts
+    targets: HashSet<String>,
+}
+
+impl DeriveCastedConstant {
+    pub fn new() -> Self {
+        DeriveCastedConstant {
+            targets: HashSet::new(),
+        }
+    }
+
+    pub fn target(mut self, name: &str) -> Self {
+        self.targets.insert(name.to_string());
+        self
+    }
+}
+
+/// Implement the ParseCallbacks trait for DeriveCastedConstant
+impl bindgen::callbacks::ParseCallbacks for DeriveCastedConstant {
+    fn modify_macro(&self, _name: &str, _tokens: &mut Vec<Token>) {
+        // modify SCIP_INVALID
+        if self.targets.contains(_name) {
+            // So here we are looking for a pattern like ['(', type, ')']
+            let position_cast = _tokens.windows(3).position(|window| match window {
+                [Token {
+                    kind: TokenKind::Punctuation,
+                    raw: left_parenthesis,
+                }, Token {
+                    // this will not go off on a cast like (SCIP_Real) as SCIP_Real is not a
+                    // Clang-keyword
+                    kind: TokenKind::Keyword,
+                    ..
+                }, Token {
+                    kind: TokenKind::Punctuation,
+                    raw: right_parenthesis,
+                }] => **left_parenthesis == *b"(" && **right_parenthesis == *b")",
+                _ => false,
+            });
+            if let Some(pos) = position_cast {
+                // position found! So a macro with a type cast exists. We remove the typecast.
+                *_tokens = [&_tokens[..pos], &_tokens[pos + 3..]].concat();
+            }
+        }
+    }
+}
