target-triple by value

milyin · milyin · commit 24df4decb678 · 2025-08-24T13:57:27.000+02:00
diff --git a/prebindgen/src/api/source.rs b/prebindgen/src/api/source.rs
@@ -70,7 +70,7 @@ pub struct Source {
     items: HashMap<String, Vec<(syn::Item, SourceLocation)>>,
     // Configuration needed to build a CfgFilter at iteration time
     features_constant: Option<String>,
-    target_triple_env_var: Option<String>,
+    target_triple: Option<String>,
     features_list: Vec<String>, // normalized list from features.txt
 }
 
@@ -95,7 +95,7 @@ impl Source {
     fn build_internal(
         input_dir: &Path,
         features_constant: Option<String>,
-        target_triple_env_var: Option<String>,
+        target_triple: Option<String>,
     ) -> Self {
         if let Some(source) = DOCTEST_SOURCE.with(|source| (*source.borrow()).clone()) {
             return source;
@@ -130,7 +130,7 @@ impl Source {
             items,
             features_constant,
             features_list,
-            target_triple_env_var,
+            target_triple,
         }
     }
 
@@ -164,7 +164,7 @@ impl Source {
                 ),
             ]),
             features_constant: None,
-            target_triple_env_var: None,
+            target_triple: None,
             features_list: Vec::new(),
         };
         DOCTEST_SOURCE.with(|cell| {
@@ -282,20 +282,9 @@ impl Source {
                 .join(" ");
             builder = builder.predefined_features(qualified_const, features_list);
         }
-        if let Some(env_var) = &self.target_triple_env_var {
-            let target = std::env::var(env_var).unwrap_or_else(|_| {
-                panic!(
-                    "Environment variable {} is not set. \
-                    Ensure that the build script sets it to the target triple.",
-                    env_var
-                )
-            });
-            let target_triple = TargetTriple::parse(&target).unwrap_or_else(|e| {
-                panic!(
-                    "Failed to parse target triple '{}' from environment variable {}: {}",
-                    target, env_var, e
-                )
-            });
+        if let Some(target) = &self.target_triple {
+            let target_triple = TargetTriple::parse(target)
+                .unwrap_or_else(|e| panic!("Failed to parse target triple '{}': {}", target, e));
             builder = builder
                 .enable_target_arch(target_triple.arch())
                 .enable_target_os(target_triple.os())
@@ -400,15 +389,16 @@ fn read_features_from_out_dir(input_dir: &Path) -> Vec<String> {
 pub struct Builder {
     input_dir: PathBuf,
     features_constant: Option<String>,
-    target_triple_env_var: Option<String>,
+    target_triple: Option<String>,
 }
 
 impl Builder {
     fn new<P: AsRef<Path>>(input_dir: P) -> Self {
+        let target_triple = std::env::var("TARGET").or(std::env::var("HOST")).ok();
         Self {
             input_dir: input_dir.as_ref().to_path_buf(),
             features_constant: Some("FEATURES".to_string()),
-            target_triple_env_var: Some("TARGET".to_string()),
+            target_triple,
         }
     }
 
@@ -448,54 +438,58 @@ impl Builder {
         self
     }
 
-    /// Enables filtering source code by target-triple which is usually
-    /// passed to `build.rs` in `TARGET` environment variable.
-    /// Accepts the name of the environment variable as an optional string.
-    /// Default value is `TARGET`.
+    /// Enables filtering source code by target-triple. This is
+    /// useful if some binding generators or custom tools over them
+    /// encounter problems with build conditions in the source code.
+    ///
+    /// Accepts the target triple string.
+    ///
+    /// Default value is the value of the environment variable
+    /// `TARGET` or `HOST` if `TARGET` is not set.
     ///
     /// Pass `None` to disable target filtering.
     ///
     /// When enabled, the code will be filtered by the target triple specified
-    /// (architecture, vendor, os, env). By default filtering is performed
-    /// by the value from the `TARGET` environment variable which contains
-    /// the target triple for the library.
+    /// (architecture, vendor, os, env).
     ///
     /// It's useful to mention that it's hard to imagine a scenario
-    /// when it's necessary to change the environment variable name.
+    /// when it's necessary to change the target triple.
     /// The `Source` object is used in the final crate, the one which builds the
-    /// no-mangle library and the language bindings (e.g. C headers). On this
-    /// stage the `TARGET` environment variable contains real target triple
-    /// even in cross-compilation scenarios. Passing the real target in the
-    /// other variable's name, e.g:
+    /// no-mangle library. On this stage the `TARGET` environment variable contains
+    /// real target triple for cross-compilation scenarios.
+    ///
+    /// There is the case when build.rs is not aware of the cross-compilation
+    /// target: the build.rs for library in [build-dependencies] section.
+    /// This is the situation which the "ffi" crate found itself in. So sometimes
+    /// for correct code generation it's necessary to inform the underlying "ffi"
+    /// crate about the real target in a way like this:
+    ///
     /// ```ignore
     /// CROSS_TARGET=x86_64-pc-windows-gnu cargo build --target x86_64-pc-windows-gnu
     /// ```
-    /// sometimes is necessary to inform the underlying "ffi" crate about the
-    /// real target triple, because it's compiled as a `build.rs` dependency on
-    /// the host platform and therefore it's target is the host.
-    /// But the `Source` is not called on this stage, so normally the access to
-    /// this `CROSS_TARGET` variable is not needed.
-    /// But for the sake of completeness the ability to use any environment variable
-    /// is provided.
-    /// It's also possible to just create standalone `CfgFilter` object
+    ///
+    /// But in typical situation this doesn't affect the `Source` object which
+    /// reads the data prepared by "ffi" crate on the following stage.
+    ///
+    /// So this `Some(<target-triple>)` is added mostly for API completeness,
+    /// typical usage if this function will be with `None` argument to disable
+    /// filtering by target triple if it's necessary to see the original
+    /// collected code.
+    ///
+    /// Notice also that it's possible to just create standalone `CfgFilter` object
     /// with necessary configuration and insert into the iterator chain.
     #[roxygen]
     pub fn enable_target_filtering(
         mut self,
-        /// Full name of the environment variable which contains the target triple
-        /// to which the code is generated
+        /// The target triple to filter collected sources
         name: Option<impl Into<String>>,
     ) -> Self {
-        self.target_triple_env_var = name.map(|n| n.into());
+        self.target_triple = name.map(|n| n.into());
         self
     }
 
     /// Build the `Source` instance
     pub fn build(self) -> Source {
-        Source::build_internal(
-            &self.input_dir,
-            self.features_constant,
-            self.target_triple_env_var,
-        )
+        Source::build_internal(&self.input_dir, self.features_constant, self.target_triple)
     }
 }
diff --git a/prebindgen/src/codegen/mod.rs b/prebindgen/src/codegen/mod.rs
@@ -26,14 +26,14 @@ pub struct CfgExprRules {
 impl CfgExprRules {
     // Return true if any rule is exists
     pub fn is_active(&self) -> bool {
-        !self.enabled_features.is_empty() || 
-        !self.disabled_features.is_empty() ||
-        !self.feature_mappings.is_empty() ||
-        self.disable_unknown_features ||
-        self.enabled_target_arch.is_some() ||
-        self.enabled_target_vendor.is_some() ||
-        self.enabled_target_os.is_some() ||
-        self.enabled_target_env.is_some()
+        !self.enabled_features.is_empty()
+            || !self.disabled_features.is_empty()
+            || !self.feature_mappings.is_empty()
+            || self.disable_unknown_features
+            || self.enabled_target_arch.is_some()
+            || self.enabled_target_vendor.is_some()
+            || self.enabled_target_os.is_some()
+            || self.enabled_target_env.is_some()
     }
 }
 
diff --git a/prebindgen/src/codegen/process_features.rs b/prebindgen/src/codegen/process_features.rs
@@ -104,11 +104,7 @@ fn process_enum_variants(
     for variant_pair in variants.pairs() {
         let mut variant = variant_pair.into_value().clone();
         // Process variant attributes
-        let keep_variant = process_attributes(
-            &mut variant.attrs,
-            rules,
-            source_location,
-        );
+        let keep_variant = process_attributes(&mut variant.attrs, rules, source_location);
 
         if keep_variant {
             // Process variant fields if it's kept
@@ -129,11 +125,7 @@ fn process_union_fields(
     let mut new_fields = syn::punctuated::Punctuated::new();
     for field_pair in fields.named.pairs() {
         let mut field = field_pair.into_value().clone();
-        if process_attributes(
-            &mut field.attrs,
-            rules,
-            source_location,
-        ) {
+        if process_attributes(&mut field.attrs, rules, source_location) {
             new_fields.push(field);
         }
     }
@@ -158,10 +150,7 @@ fn process_attributes(
                 match CfgExpr::parse_from_tokens(&meta_list.tokens) {
                     Ok(cfg_expr) => {
                         // Apply strict feature processing
-                        match cfg_expr.apply_rules(
-                            rules,
-                            source_location,
-                        ) {
+                        match cfg_expr.apply_rules(rules, source_location) {
                             Some(processed_expr) => {
                                 // Check if the processed expression is CfgExpr::False
                                 if matches!(processed_expr, CfgExpr::False) {
diff --git a/prebindgen/src/codegen/tests/cfg_expr.rs b/prebindgen/src/codegen/tests/cfg_expr.rs
@@ -30,7 +30,10 @@ fn test_target_filters_processing() {
 
     // With no selection, keep predicates as-is
     let expr = CfgExpr::TargetOs("macos".into());
-    assert_eq!(expr.apply_rules(&CfgExprRules::default(), &src), Some(CfgExpr::TargetOs("macos".into())));
+    assert_eq!(
+        expr.apply_rules(&CfgExprRules::default(), &src),
+        Some(CfgExpr::TargetOs("macos".into()))
+    );
 
     // No selection for arch/vendor/env should also keep predicates as-is
     assert_eq!(
@@ -49,7 +52,10 @@ fn test_target_filters_processing() {
     // Select OS = macos: becomes true (None)
     assert_eq!(
         CfgExpr::TargetOs("macos".into()).apply_rules(
-            &CfgExprRules { enabled_target_os: Some("macos".into()), ..Default::default() },
+            &CfgExprRules {
+                enabled_target_os: Some("macos".into()),
+                ..Default::default()
+            },
             &src,
         ),
         None
@@ -58,7 +64,10 @@ fn test_target_filters_processing() {
     // Non-matching becomes False
     assert_eq!(
         CfgExpr::TargetOs("linux".into()).apply_rules(
-            &CfgExprRules { enabled_target_os: Some("macos".into()), ..Default::default() },
+            &CfgExprRules {
+                enabled_target_os: Some("macos".into()),
+                ..Default::default()
+            },
             &src,
         ),
         Some(CfgExpr::False)
@@ -67,14 +76,20 @@ fn test_target_filters_processing() {
     // Arch selection
     assert_eq!(
         CfgExpr::TargetArch("x86_64".into()).apply_rules(
-            &CfgExprRules { enabled_target_arch: Some("x86_64".into()), ..Default::default() },
+            &CfgExprRules {
+                enabled_target_arch: Some("x86_64".into()),
+                ..Default::default()
+            },
             &src,
         ),
         None
     );
     assert_eq!(
         CfgExpr::TargetArch("aarch64".into()).apply_rules(
-            &CfgExprRules { enabled_target_arch: Some("x86_64".into()), ..Default::default() },
+            &CfgExprRules {
+                enabled_target_arch: Some("x86_64".into()),
+                ..Default::default()
+            },
             &src,
         ),
         Some(CfgExpr::False)
@@ -83,30 +98,42 @@ fn test_target_filters_processing() {
     // Vendor and Env selection
     assert_eq!(
         CfgExpr::TargetVendor("apple".into()).apply_rules(
-            &CfgExprRules { enabled_target_vendor: Some("apple".into()), ..Default::default() },
+            &CfgExprRules {
+                enabled_target_vendor: Some("apple".into()),
+                ..Default::default()
+            },
             &src,
         ),
         None
     );
     // Non-matching vendor becomes False
     assert_eq!(
         CfgExpr::TargetVendor("unknown".into()).apply_rules(
-            &CfgExprRules { enabled_target_vendor: Some("apple".into()), ..Default::default() },
+            &CfgExprRules {
+                enabled_target_vendor: Some("apple".into()),
+                ..Default::default()
+            },
             &src,
         ),
         Some(CfgExpr::False)
     );
     assert_eq!(
         CfgExpr::TargetEnv("gnu".into()).apply_rules(
-            &CfgExprRules { enabled_target_env: Some("gnu".into()), ..Default::default() },
+            &CfgExprRules {
+                enabled_target_env: Some("gnu".into()),
+                ..Default::default()
+            },
             &src,
         ),
         None
     );
     // Non-matching env becomes False
     assert_eq!(
         CfgExpr::TargetEnv("msvc".into()).apply_rules(
-            &CfgExprRules { enabled_target_env: Some("gnu".into()), ..Default::default() },
+            &CfgExprRules {
+                enabled_target_env: Some("gnu".into()),
+                ..Default::default()
+            },
             &src,
         ),
         Some(CfgExpr::False)
@@ -259,10 +286,7 @@ fn test_strict_feature_processing() {
 fn test_strict_feature_processing_unmapped_panic() {
     // Test unmapped feature - should panic
     let expr = CfgExpr::Feature("unknown".to_string());
-    expr.apply_rules(
-    &CfgExprRules::default(),
-        &SourceLocation::default(),
-    );
+    expr.apply_rules(&CfgExprRules::default(), &SourceLocation::default());
 }
 
 #[test]
diff --git a/prebindgen/src/codegen/tests/mod.rs b/prebindgen/src/codegen/tests/mod.rs
@@ -1 +1 @@
-mod cfg_expr;
+mod cfg_expr;
