add cfg_if! and cfg_if_expr! macro_rules macros

cosmicexplorer · cosmicexplorer · commit b16f33d45e61 · 2025-09-30T09:46:41.000-04:00
diff --git a/examples/write_dir.rs b/examples/write_dir.rs
@@ -3,7 +3,7 @@
 use anyhow::Context;
 use clap::{Parser, ValueEnum};
 use std::io::prelude::*;
-use zip::{result::ZipError, write::SimpleFileOptions};
+use zip::{cfg_if_expr, result::ZipError, write::SimpleFileOptions};
 
 use std::fs::File;
 use std::path::{Path, PathBuf};
@@ -40,42 +40,34 @@ fn real_main() -> i32 {
     let dst_file = &args.destination;
     let method = match args.compression_method {
         CompressionMethod::Stored => zip::CompressionMethod::Stored,
-        CompressionMethod::Deflated => {
-            #[cfg(not(feature = "deflate-flate2"))]
-            {
+        CompressionMethod::Deflated => cfg_if_expr! {
+            #[cfg(feature = "deflate-flate2")] => zip::CompressionMethod::Deflated,
+            _ => {
                 println!("The `deflate-flate2` feature is not enabled");
-                return 1;
+                std::process::exit(1)
             }
-            #[cfg(feature = "deflate-flate2")]
-            zip::CompressionMethod::Deflated
-        }
-        CompressionMethod::Bzip2 => {
-            #[cfg(not(feature = "bzip2"))]
-            {
+        },
+        CompressionMethod::Bzip2 => cfg_if_expr! {
+            #[cfg(feature = "bzip2")] => zip::CompressionMethod::Bzip2,
+            _ => {
                 println!("The `bzip2` feature is not enabled");
-                return 1;
+                std::process::exit(1);
             }
-            #[cfg(feature = "bzip2")]
-            zip::CompressionMethod::Bzip2
-        }
-        CompressionMethod::Xz => {
-            #[cfg(not(feature = "xz"))]
-            {
+        },
+        CompressionMethod::Xz => cfg_if_expr! {
+            #[cfg(feature = "xz")] => zip::CompressionMethod::Xz,
+            _ => {
                 println!("The `xz` feature is not enabled");
-                return 1;
+                std::process::exit(1);
             }
-            #[cfg(feature = "xz")]
-            zip::CompressionMethod::Xz
-        }
-        CompressionMethod::Zstd => {
-            #[cfg(not(feature = "zstd"))]
-            {
+        },
+        CompressionMethod::Zstd => cfg_if_expr! {
+            #[cfg(feature = "zstd")] => zip::CompressionMethod::Zstd,
+            _ => {
                 println!("The `zstd` feature is not enabled");
-                return 1;
+                std::process::exit(1);
             }
-            #[cfg(feature = "zstd")]
-            zip::CompressionMethod::Zstd
-        }
+        },
     };
     match doit(src_dir, dst_file, method) {
         Ok(_) => println!("done: {src_dir:?} written to {dst_file:?}"),
diff --git a/fuzz_read/src/main.rs b/fuzz_read/src/main.rs
@@ -1,6 +1,7 @@
 use afl::fuzz;
 use std::io::{Read, Seek, SeekFrom};
 use tikv_jemallocator::Jemalloc;
+use zip::cfg_if;
 use zip::read::read_zipfile_from_stream;
 
 const MAX_BYTES_TO_READ: u64 = 1 << 24;
diff --git a/src/compression.rs b/src/compression.rs
@@ -2,6 +2,8 @@
 
 use std::{fmt, io};
 
+use crate::cfg_if_expr;
+
 #[allow(deprecated)]
 /// Identifies the storage format used to compress a file within a ZIP archive.
 ///
@@ -228,11 +230,10 @@ impl CompressionMethod {
 
 impl Default for CompressionMethod {
     fn default() -> Self {
-        #[cfg(feature = "_deflate-any")]
-        return CompressionMethod::Deflated;
-
-        #[cfg(not(feature = "_deflate-any"))]
-        return CompressionMethod::Stored;
+        cfg_if_expr! {
+            #[cfg(feature = "_deflate-any")] => CompressionMethod::Deflated,
+            _ => CompressionMethod::Stored
+        }
     }
 }
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -71,3 +71,6 @@ zip = \"="]
 #[doc = "\"\n\
 ```"]
 pub mod unstable;
+
+#[doc(hidden)]
+pub mod macros;
diff --git a/src/macros.rs b/src/macros.rs
@@ -0,0 +1,141 @@
+//! Macros used internally.
+//!
+//! These may technically be exported, but that's only to make them available to internal
+//! project dependencies. The `#[doc(hidden)]` mark indicates that these are not stable or supported
+//! APIs, and should not be relied upon by external dependees.
+
+/// The single macro export of the [`cfg-if`](https://docs.rs/cfg-if) crate.
+///
+/// It is packaged here to avoid pulling in another dependency. The stdlib does the same[^1].
+///
+/// [^1]: https://github.com/rust-lang/rust/blob/a2db9280539229a3b8a084a09886670a57bc7e9c/library/compiler-builtins/libm/src/math/support/macros.rs#L1
+#[doc(hidden)]
+#[macro_export]
+macro_rules! cfg_if {
+    // match if/else chains with a final `else`
+    (
+        $(
+            if #[cfg( $i_meta:meta )] { $( $i_tokens:tt )* }
+        ) else+
+        else { $( $e_tokens:tt )* }
+    ) => {
+        $crate::cfg_if! {
+            @__items () ;
+            $(
+                (( $i_meta ) ( $( $i_tokens )* )) ,
+            )+
+            (() ( $( $e_tokens )* )) ,
+        };
+    };
+
+    // match if/else chains lacking a final `else`
+    (
+        if #[cfg( $i_meta:meta )] { $( $i_tokens:tt )* }
+        $(
+            else if #[cfg( $e_meta:meta )] { $( $e_tokens:tt )* }
+        )*
+    ) => {
+        $crate::cfg_if! {
+            @__items () ;
+            (( $i_meta ) ( $( $i_tokens )* )) ,
+            $(
+                (( $e_meta ) ( $( $e_tokens )* )) ,
+            )*
+        };
+    };
+
+    // Internal and recursive macro to emit all the items
+    //
+    // Collects all the previous cfgs in a list at the beginning, so they can be
+    // negated. After the semicolon are all the remaining items.
+    (@__items ( $( $_:meta , )* ) ; ) => {};
+    (
+        @__items ( $( $no:meta , )* ) ;
+        (( $( $yes:meta )? ) ( $( $tokens:tt )* )) ,
+        $( $rest:tt , )*
+    ) => {
+        // Emit all items within one block, applying an appropriate #[cfg]. The
+        // #[cfg] will require all `$yes` matchers specified and must also negate
+        // all previous matchers.
+        #[cfg(all(
+            $( $yes , )?
+            not(any( $( $no ),* ))
+        ))]
+        $crate::cfg_if! { @__identity $( $tokens )* }
+
+        // Recurse to emit all other items in `$rest`, and when we do so add all
+        // our `$yes` matchers to the list of `$no` matchers as future emissions
+        // will have to negate everything we just matched as well.
+        $crate::cfg_if! {
+            @__items ( $( $no , )* $( $yes , )? ) ;
+            $( $rest , )*
+        };
+    };
+
+    // Internal macro to make __apply work out right for different match types,
+    // because of how macros match/expand stuff.
+    (@__identity $( $tokens:tt )* ) => {
+        $( $tokens )*
+    };
+}
+
+/// Similar to [`cfg_if`](cfg_if), but accepts a list of expressions, and generates an internal
+/// closure to return each value.
+///
+/// The generated closure is non-[`const`](const@keyword), so cannot be used inside `const` methods.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! cfg_if_expr {
+    // Match :, chains, maybe with a final _: catchall clause.
+    (
+        $(
+            #[cfg( $i_meta:meta )] => $i_val:expr
+        ),+ ,
+            _ => $rem_val:expr $(,)?
+    ) => {
+        (|| {
+            $crate::cfg_if_expr! {
+                @__items ();
+                $(
+                    (( $i_meta ) ( return $i_val ; )) ,
+                )+
+                    (() ( return $rem_val ; )) ,
+            }
+        })()
+    };
+    (
+        $(
+            #[cfg( $i_meta:meta )] => $i_val:expr
+        ),+ $(,)?
+    ) => {
+        (|| {
+            $crate::cfg_if_expr! {
+                @__items ();
+                $(
+                    (( $i_meta ) ( return $i_val ; )) ,
+                )+
+            }
+        })()
+    };
+
+    (@__items ( $( $_:meta , )* ) ; ) => {};
+    (
+        @__items ( $( $no:meta , )* ) ;
+        (( $( $yes:meta )? ) ( $( $tokens:tt )* )) ,
+        $( $rest:tt , )*
+    ) => {
+        #[cfg(all(
+            $( $yes , )?
+            not(any( $( $no ),* ))
+        ))]
+        $crate::cfg_if_expr! { @__identity $( $tokens )* }
+
+        $crate::cfg_if_expr! {
+            @__items ( $( $no , )* $( $yes , )? ) ;
+            $( $rest , )*
+        };
+    };
+    (@__identity $( $tokens:tt )* ) => {
+        $( $tokens )*
+    };
+}
diff --git a/src/read.rs b/src/read.rs
@@ -2,6 +2,7 @@
 
 #[cfg(feature = "aes-crypto")]
 use crate::aes::{AesReader, AesReaderValid};
+use crate::cfg_if;
 use crate::compression::{CompressionMethod, Decompressor};
 use crate::cp437::FromCp437;
 use crate::crc32::Crc32Reader;
@@ -172,16 +173,20 @@ impl<'a, R: Read> CryptoReader<'a, R> {
 
     /// Returns `true` if the data is encrypted using AE2.
     pub const fn is_ae2_encrypted(&self) -> bool {
-        #[cfg(feature = "aes-crypto")]
-        return matches!(
-            self,
-            CryptoReader::Aes {
-                vendor_version: AesVendorVersion::Ae2,
-                ..
+        cfg_if! {
+            if #[cfg(feature = "aes-crypto")] {
+                #[allow(clippy::needless_return)]
+                return matches!(
+                    self,
+                    CryptoReader::Aes {
+                        vendor_version: AesVendorVersion::Ae2,
+                        ..
+                    }
+                );
+            } else {
+                return false;
             }
-        );
-        #[cfg(not(feature = "aes-crypto"))]
-        false
+        }
     }
 }
 
@@ -454,34 +459,32 @@ pub(crate) fn make_symlink<T>(
         return Err(invalid!("Invalid UTF-8 as symlink target"));
     };
 
-    #[cfg(not(any(unix, windows)))]
-    {
-        use std::fs::File;
-        let output = File::create(outpath);
-        output?.write_all(target)?;
-    }
-    #[cfg(unix)]
-    {
-        std::os::unix::fs::symlink(Path::new(&target_str), outpath)?;
-    }
-    #[cfg(windows)]
-    {
-        let target = Path::new(OsStr::new(&target_str));
-        let target_is_dir_from_archive =
-            existing_files.contains_key(target_str) && is_dir(target_str);
-        let target_is_dir = if target_is_dir_from_archive {
-            true
-        } else if let Ok(meta) = std::fs::metadata(target) {
-            meta.is_dir()
-        } else {
-            false
-        };
-        if target_is_dir {
-            std::os::windows::fs::symlink_dir(target, outpath)?;
+    cfg_if! {
+        if #[cfg(unix)] {
+            std::os::unix::fs::symlink(Path::new(&target_str), outpath)?;
+        } else if #[cfg(windows)] {
+            let target = Path::new(OsStr::new(&target_str));
+            let target_is_dir_from_archive =
+                existing_files.contains_key(target_str) && is_dir(target_str);
+            let target_is_dir = if target_is_dir_from_archive {
+                true
+            } else if let Ok(meta) = std::fs::metadata(target) {
+                meta.is_dir()
+            } else {
+                false
+            };
+            if target_is_dir {
+                std::os::windows::fs::symlink_dir(target, outpath)?;
+            } else {
+                std::os::windows::fs::symlink_file(target, outpath)?;
+            }
         } else {
-            std::os::windows::fs::symlink_file(target, outpath)?;
+            use std::fs::File;
+            let output = File::create(outpath);
+            output?.write_all(target)?;
         }
     }
+
     Ok(())
 }
 
@@ -890,25 +893,30 @@ impl<R: Read + Seek> ZipArchive<R> {
             let mut outpath = directory.clone();
             file.safe_prepare_path(directory.as_ref(), &mut outpath, root_dir.as_ref())?;
 
-            let symlink_target = if file.is_symlink() && (cfg!(unix) || cfg!(windows)) {
-                let mut target = Vec::with_capacity(file.size() as usize);
-                file.read_to_end(&mut target)?;
-                Some(target)
-            } else {
-                if file.is_dir() {
-                    crate::read::make_writable_dir_all(&outpath)?;
-                    continue;
+            let mut symlink_target: Option<Vec<u8>> = None;
+            cfg_if! {
+                if #[cfg(any(unix, windows))] {
+                    if file.is_symlink() {
+                        let mut target = Vec::with_capacity(file.size() as usize);
+                        file.read_to_end(&mut target)?;
+                        symlink_target = Some(target);
+                    }
+                } else {
+                    if file.is_symlink() {
+                        todo!("no support for symlinks outside of unix or windows platforms");
+                    }
                 }
-                None
-            };
-
-            drop(file);
+            }
+            if symlink_target.is_none() && file.is_dir() {
+                crate::read::make_writable_dir_all(&outpath)?;
+                continue;
+            }
 
             if let Some(target) = symlink_target {
+                drop(file);
                 make_symlink(&outpath, &target, &self.shared.files)?;
                 continue;
             }
-            let mut file = self.by_index(i)?;
             let mut outfile = fs::File::create(&outpath)?;
 
             io::copy(&mut file, &mut outfile)?;
diff --git a/src/types.rs b/src/types.rs
diff --git a/src/zipcrypto.rs b/src/zipcrypto.rs
