Merge pull request #36 from HunkBenny/main

mmghannam · web-flow · commit cda52bb7f851 · 2025-12-16T08:01:14.000+01:00
Add `def.h` to bindgen + solved deprecation warning
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,11 +62,19 @@ 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)
-        .parse_callbacks(Box::new(bindgen::CargoCallbacks))
+        .header(scipdef_file)
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
         .clang_arg(format!("-I{}", include_dir_path))
 }
 
@@ -90,7 +100,7 @@ fn look_in_scipoptdir_and_conda_env() -> Option<bindgen::Builder> {
         }
     }
 
-    return None;
+    None
 }
 
 fn try_system_include_paths() -> Option<bindgen::Builder> {
@@ -100,25 +110,27 @@ 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 {
         let base = PathBuf::from(base_path);
         let scip_h = base.join("scip").join("scip.h");
         let scipdefplugins_h = base.join("scip").join("scipdefplugins.h");
+        let def_h = base.join("scip").join("def.h");
 
-        if scip_h.exists() && scipdefplugins_h.exists() {
+        if scip_h.exists() && scipdefplugins_h.exists() && def_h.exists() {
             println!("cargo:warning=Found SCIP headers in {}", base_path);
 
             return Some(
                 bindgen::Builder::default()
                     .header(scip_h.to_str().unwrap())
                     .header(scipdefplugins_h.to_str().unwrap())
-                    .parse_callbacks(Box::new(bindgen::CargoCallbacks))
-                    .clang_arg(format!("-I{}", base_path))
+                    .header(def_h.to_str().unwrap())
+                    .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+                    .clang_arg(format!("-I{}", base_path)),
             );
         }
     }
@@ -188,14 +200,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::new()))
+        .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::{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();
+            }
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -10,8 +10,8 @@ include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 
 #[cfg(test)]
 mod tests {
-    use std::ffi::CString;
     use super::*;
+    use std::ffi::CString;
     use std::mem::MaybeUninit;
 
     #[test]
@@ -68,5 +68,7 @@ mod tests {
         unsafe { SCIPreleaseVar(scip_ptr, &mut var_ptr) };
         unsafe { SCIPreleaseCons(scip_ptr, &mut cons_ptr) };
         unsafe { SCIPfree(&mut scip_ptr) };
+        // Get some constants defined in def.h
+        println!("Found SCIP_INVALID: {}", SCIP_INVALID);
     }
 }
