fix: generate bindings by passing argument

Author: leftger

stm32-bindings-gen/src/lib.rs

@@ -19,6 +19,7 @@ impl ParseCallbacks for UppercaseCallbacks {
 pub struct Options {
     pub out_dir: PathBuf,
     pub sources_dir: PathBuf,
+    pub target_triple: String,
 }
 
 pub struct Gen {
@@ -48,14 +49,25 @@ impl Gen {
         // The bindgen::Builder is the main entry point
         // to bindgen, and lets you build up options for
         // the resulting bindings.
-        let bindings = bindgen::Builder::default()
+        let target_flag = format!("--target={}", self.opts.target_triple);
+        let include_arg = format!(
+            "-I{}/Middlewares/ST/STM32_WPAN/mac_802_15_4/core/inc",
+            self.opts.sources_dir.to_str().unwrap()
+        );
+        let mut builder = bindgen::Builder::default()
             .parse_callbacks(Box::new(UppercaseCallbacks))
-            // Force Clang to use the same 32-bit target layout as the firmware.
-            .clang_args(["--target=thumbv8m.main-none-eabihf", "-mthumb"])
-            .clang_arg(format!(
-                "-I{}/Middlewares/ST/STM32_WPAN/mac_802_15_4/core/inc",
-                self.opts.sources_dir.to_str().unwrap()
-            ))
+            // Force Clang to use the same layout as the selected target.
+            .clang_arg(&target_flag)
+            .clang_arg(&include_arg);
+        if self
+            .opts
+            .target_triple
+            .to_ascii_lowercase()
+            .starts_with("thumb")
+        {
+            builder = builder.clang_arg("-mthumb");
+        }
+        let bindings = builder
             // The input header we would like to generate
             // bindings for.
             .header("stm32-bindings-gen/inc/wpan-wba.h")

stm32-bindings-gen/src/main.rs

@@ -1,16 +1,70 @@
-use std::path::PathBuf;
+use std::{env, path::PathBuf, process};
 
 use stm32_bindings_gen::{Gen, Options};
 
 fn main() {
     let out_dir = PathBuf::from("build/stm32-bindings");
     let sources_dir = PathBuf::from("sources");
-
-    // let args: Vec<String> = args().collect();
+    let target_triple = resolve_target_triple();
 
     let opts = Options {
         out_dir,
         sources_dir,
+        target_triple,
     };
     Gen::new(opts).run_gen();
 }
+
+fn resolve_target_triple() -> String {
+    let mut args = env::args().skip(1);
+    let mut positional: Option<String> = None;
+
+    while let Some(arg) = args.next() {
+        match arg.as_str() {
+            "--help" | "-h" => {
+                eprintln!("Usage: stm32-bindings-gen [--target <triple>] [triple]");
+                process::exit(0);
+            }
+            "--target" => {
+                let value = args.next().unwrap_or_else(|| {
+                    eprintln!("Expected a value after --target");
+                    process::exit(1);
+                });
+                let trimmed = value.trim();
+                if trimmed.is_empty() {
+                    eprintln!("Target triple cannot be empty.");
+                    process::exit(1);
+                }
+                return trimmed.to_string();
+            }
+            _ => {
+                if let Some(value) = arg.strip_prefix("--target=") {
+                    let trimmed = value.trim();
+                    if trimmed.is_empty() {
+                        eprintln!("Target triple cannot be empty.");
+                        process::exit(1);
+                    }
+                    return trimmed.to_string();
+                }
+                if positional.is_none() {
+                    let trimmed = arg.trim();
+                    if !trimmed.is_empty() {
+                        positional = Some(trimmed.to_string());
+                    }
+                }
+            }
+        }
+    }
+
+    positional
+        .or_else(|| env::var("BINDGEN_TARGET").ok())
+        .and_then(|s| {
+            let trimmed = s.trim();
+            if trimmed.is_empty() {
+                None
+            } else {
+                Some(trimmed.to_string())
+            }
+        })
+        .unwrap_or_else(|| "thumbv8m.main-none-eabihf".to_string())
+}