Add executable no_std example

Uses QEMU and the UEFI crate to create a no_std compatible example which can run in CI.

Author: bushrat011899

.github/workflows/main.yml

@@ -125,6 +125,24 @@ jobs:
       # Testing the `no_std` confirmation is done above.
     - run: cargo build ${{ matrix.flags }} --target ${{ matrix.target }} --no-default-features --features rust_backend
 
+  no_std_example:
+    name: no_std (Example)
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64-unknown-uefi, x86_64-unknown-linux-gnu]
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install Rust
+      run: rustup update nightly && rustup default nightly
+    - name: Install Target
+      run: rustup target add ${{ matrix.target }}
+    - name: Install QEMU
+      run: sudo apt update && sudo apt install qemu-system qemu-utils ovmf -y && sudo chmod +x ./examples/no_std/run.uefi.sh
+      if: matrix.target == 'x86_64-unknown-uefi'
+    - run: cargo run --target ${{ matrix.target }} --features qemu
+      working-directory: ./examples/no_std
+
   minimum:
     name: Minimum Rust compiler
     runs-on: ${{ matrix.os }}

examples/no_std/.cargo/config.toml

@@ -0,0 +1,3 @@
+[target.'cfg(all(target_arch = "x86_64", target_os = "uefi"))']
+rustflags = ["--cfg", "flate2_unstable_nightly_alloc_io"]
+runner = "./run.uefi.sh"

examples/no_std/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "flate2_example_no_std"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[features]
+qemu = ["dep:qemu-exit", "uefi/qemu"]
+
+[dependencies]
+log = "0.4"
+flate2 = { path = "../../", default-features = false, features = ["rust_backend"] }
+
+[target.'cfg(target_os = "uefi")'.dependencies]
+uefi = { version = "0.39.0", features = ["logger", "panic_handler", "global_allocator"] }
+qemu-exit = { version = "4", optional = true }
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+priority = 0
+check-cfg = [
+    ## Enables `no_std` support by using `core::error` and `alloc::io`.
+    ## Requires at least nightly 2026-07-19.
+    "cfg(flate2_unstable_nightly_alloc_io)",
+]

examples/no_std/run.uefi.sh

@@ -0,0 +1,12 @@
+mkdir -p target/esp/efi/boot
+cp $1 target/esp/efi/boot/bootx64.efi
+qemu-system-x86_64 -device isa-debug-exit,iobase=0xf4,iosize=0x04 \
+    -drive if=pflash,format=raw,readonly=on,file=/usr/share/OVMF/OVMF_CODE_4M.fd \
+    -drive if=pflash,format=raw,readonly=on,file=/usr/share/OVMF/OVMF_VARS_4M.fd \
+    -drive format=raw,file=fat:rw:target/esp \
+    --nographic
+if [ $? -ne 123 ]; then
+    exit $?
+else
+    exit 0
+fi

examples/no_std/src/lib.rs

@@ -0,0 +1,47 @@
+#![no_std]
+#![cfg_attr(flate2_unstable_nightly_alloc_io, feature(alloc_io))]
+
+extern crate alloc;
+
+cfg_select! {
+    flate2_unstable_nightly_alloc_io => {
+        use alloc::io;
+        use log::info as println;
+    }
+    _ => {
+        extern crate std;
+        use std::io;
+        use std::println;
+    }
+}
+
+use alloc::string::String;
+use alloc::vec::Vec;
+use io::prelude::*;
+
+use flate2::write::GzEncoder;
+use flate2::{read, Compression};
+
+// Compress a sample string and print it after transformation.
+pub fn main() {
+    let input = "Hello World";
+
+    let mut e = GzEncoder::new(Vec::new(), Compression::default());
+    e.write_all(input.as_bytes()).unwrap();
+    let bytes = e.finish().unwrap();
+    println!("Compressed '{input}' into: {bytes:?}");
+
+    let output = decode_reader(bytes).unwrap();
+    println!("Decompressed into: {output}");
+
+    assert_eq!(input, &output);
+}
+
+// Uncompresses a Gz-encoded vector of bytes and returns a string or error
+// Here &[u8] implements the Read trait
+fn decode_reader(bytes: Vec<u8>) -> io::Result<String> {
+    let mut gz = read::GzDecoder::new(&bytes[..]);
+    let mut s = String::new();
+    gz.read_to_string(&mut s)?;
+    Ok(s)
+}

examples/no_std/src/main.rs

@@ -0,0 +1,32 @@
+#![cfg_attr(target_os = "uefi", no_main)]
+#![no_std]
+
+cfg_select! {
+    target_os = "uefi" => {
+        #[uefi::entry]
+        fn main() -> uefi::Status {
+            uefi::helpers::init().unwrap();
+
+            flate2_example_no_std::main();
+
+            cfg_select! {
+                not(feature = "qemu") => {
+                    uefi::Status::SUCCESS
+                }
+                any(target_arch = "x86", target_arch = "x86_64") => {
+                    use qemu_exit::QEMUExit;
+                    let qemu_exit_handle = unsafe { qemu_exit::X86::new(0xF4, 123) };
+                    qemu_exit_handle.exit_success();
+                }
+                _ => unimplemented!()
+            }
+        }
+    }
+    _ => {
+        extern crate std;
+
+        fn main() {
+            flate2_example_no_std::main();
+        }
+    }
+}