Fully support building in no_std configuration

trifectatechfoundation · Nov 12, 2024 · 4747688 · 4747688
1 parent dee3698
commit 4747688
Show file tree

Hide file tree

Showing 8 changed files with 79 additions and 33 deletions.
diff --git a/.github/workflows/checks.yaml b/.github/workflows/checks.yaml
@@ -82,6 +82,10 @@ jobs:
           tool: cargo-nextest
       - name: cargo build
         run: cargo build --target ${{matrix.target}} ${{ matrix.features }}
+      - name: cargo build (no_std)
+        run: cargo rustc --target ${{matrix.target}} -p libbzip2-rs-sys --lib --no-default-features --crate-type rlib
+        env:
+          RUSTFLAGS: -Aunused_variables -Aunused_assignments
       - name: cargo nextest # reports segfaults in a helpful way
         run: cargo nextest run --target ${{matrix.target}} ${{ matrix.features }} --no-fail-fast --workspace
         env:

diff --git a/Cargo.toml b/Cargo.toml
@@ -29,7 +29,7 @@ libbzip2-rs-sys = { path = "libbzip2-rs-sys/", default-features = false }
 
 [dependencies]
 libc = "0.2"
-libbzip2-rs-sys = { path = "libbzip2-rs-sys/", default-features = false }
+libbzip2-rs-sys = { path = "libbzip2-rs-sys/" }
 
 [dev-dependencies]
 tempfile = "3.13.0"

diff --git a/blocksort.rs b/blocksort.rs
@@ -238,7 +238,8 @@ fn fallbackSort(
        initial fmap and initial BH bits.
     --*/
     if verb >= 4 {
-        eprintln!("        bucket sorting ...");
+        #[cfg(feature = "std")]
+        std::eprintln!("        bucket sorting ...");
     }
 
     {
@@ -284,7 +285,8 @@ fn fallbackSort(
     H = 1;
     loop {
         if verb >= 4 {
-            eprint!("        depth {:>6} has ", H);
+            #[cfg(feature = "std")]
+            std::eprint!("        depth {:>6} has ", H);
         }
         j = 0;
         i = 0;
@@ -352,7 +354,8 @@ fn fallbackSort(
             }
         }
         if verb >= 4 {
-            eprintln!("{:>6} unresolved strings", nNotDone);
+            #[cfg(feature = "std")]
+            std::eprintln!("{:>6} unresolved strings", nNotDone);
         }
         H *= 2;
         if H > nblock || nNotDone == 0 {
@@ -361,7 +364,8 @@ fn fallbackSort(
     }
 
     if verb >= 4 {
-        eprintln!("        reconstructing block ...");
+        #[cfg(feature = "std")]
+        std::eprintln!("        reconstructing block ...");
     }
 
     {
@@ -959,7 +963,8 @@ fn mainSort(
     let mut numQSorted: i32;
     let mut s: u16;
     if verb >= 4 as c_int {
-        eprintln!("        main sort initialise ...");
+        #[cfg(feature = "std")]
+        std::eprintln!("        main sort initialise ...");
     }
 
     /*-- set up the 2-byte frequency table --*/
@@ -994,7 +999,8 @@ fn mainSort(
     }
 
     if verb >= 4 as c_int {
-        eprintln!("        bucket sorting ...");
+        #[cfg(feature = "std")]
+        std::eprintln!("        bucket sorting ...");
     }
 
     /*-- Complete the initial radix sort --*/
@@ -1114,7 +1120,8 @@ fn mainSort(
 
                     if hi > lo {
                         if verb >= 4 as c_int {
-                            eprintln!(
+                            #[cfg(feature = "std")]
+                            std::eprintln!(
                                 "        qsort [{:#x}, {:#x}]   done {}   this {}",
                                 ss,
                                 j,
@@ -1258,7 +1265,8 @@ fn mainSort(
         }
     }
     if verb >= 4 as c_int {
-        eprintln!(
+        #[cfg(feature = "std")]
+        std::eprintln!(
             "        {} pointers, {} sorted, {} scanned",
             nblock,
             numQSorted,
@@ -1332,7 +1340,8 @@ fn BZ2_blockSortHelp(
         );
 
         if verbosity >= 3 {
-            eprintln!(
+            #[cfg(feature = "std")]
+            std::eprintln!(
                 "      {} work, {} block, ratio {:5.2}",
                 budgetInit - budget,
                 nblock,
@@ -1342,7 +1351,8 @@ fn BZ2_blockSortHelp(
 
         if budget < 0 {
             if verbosity >= 2 as c_int {
-                eprintln!("    too repetitive; using fallback sorting algorithm");
+                #[cfg(feature = "std")]
+                std::eprintln!("    too repetitive; using fallback sorting algorithm");
             }
 
             fallbackSort(ptr, arr2, ftab, nblock as i32, verbosity);

diff --git a/bzlib.rs b/bzlib.rs
@@ -1648,13 +1648,16 @@ unsafe fn BZ2_bzDecompressHelp(strm: &mut bz_stream) -> ReturnCode {
             if s.nblock_used == s.save_nblock + 1 && s.state_out_len == 0 {
                 s.calculatedBlockCRC = !s.calculatedBlockCRC;
                 if s.verbosity >= 3 {
-                    eprint!(
+                    #[cfg(feature = "std")]
+                    std::eprint!(
                         " {{{:#08x}, {:#08x}}}",
-                        s.storedBlockCRC, s.calculatedBlockCRC,
+                        s.storedBlockCRC,
+                        s.calculatedBlockCRC,
                     );
                 }
                 if s.verbosity >= 2 {
-                    eprint!("]");
+                    #[cfg(feature = "std")]
+                    std::eprint!("]");
                 }
                 if s.calculatedBlockCRC != s.storedBlockCRC {
                     return ReturnCode::BZ_DATA_ERROR;
@@ -1672,9 +1675,11 @@ unsafe fn BZ2_bzDecompressHelp(strm: &mut bz_stream) -> ReturnCode {
             _ => match BZ2_decompress(strm, s) {
                 ReturnCode::BZ_STREAM_END => {
                     if s.verbosity >= 3 {
-                        eprint!(
+                        #[cfg(feature = "std")]
+                        std::eprint!(
                             "\n    combined CRCs: stored = {:#08x}, computed = {:#08x}",
-                            s.storedCombinedCRC, s.calculatedCombinedCRC,
+                            s.storedCombinedCRC,
+                            s.calculatedCombinedCRC,
                         );
                     }
                     if s.calculatedCombinedCRC != s.storedCombinedCRC {

diff --git a/c2rust-lib.rs b/c2rust-lib.rs
@@ -1,10 +1,14 @@
+#![no_std]
 #![allow(non_snake_case)]
 #![allow(clippy::too_many_arguments)]
 #![allow(clippy::missing_safety_doc)] // FIXME remove once everything has safety docs
 #![allow(clippy::needless_range_loop)] // FIXME remove once all instances are fixed
 
 //! A drop-in compatible rust implementation of bzip2
 
+#[cfg(feature = "std")]
+extern crate std;
+
 use core::ffi::c_int;
 
 mod blocksort;
@@ -71,8 +75,13 @@ pub(crate) use libbzip2_rs_sys_version;
 macro_rules! assert_h {
     ($condition:expr, $errcode:expr) => {{
         if !$condition {
-            eprint!("{}", $crate::AssertFail($errcode));
+            #[cfg(feature = "std")]
+            std::eprint!("{}", $crate::AssertFail($errcode));
+            #[cfg(feature = "std")]
             std::process::exit(3);
+
+            #[cfg(not(feature = "std"))]
+            panic!("{}", $crate::AssertFail($errcode));
         }
     }};
 }

diff --git a/compress.rs b/compress.rs
@@ -234,9 +234,12 @@ fn sendMTFValues(s: &mut EState) {
     let mtfv = s.arr1.mtfv();
 
     if s.verbosity >= 3 {
-        eprintln!(
+        #[cfg(feature = "std")]
+        std::eprintln!(
             "      {} in block, {} after MTF & 1-2 coding, {}+2 syms in use",
-            s.nblock, s.nMTF, s.nInUse,
+            s.nblock,
+            s.nMTF,
+            s.nInUse,
         );
     }
 
@@ -283,7 +286,8 @@ fn sendMTFValues(s: &mut EState) {
             }
 
             if s.verbosity >= 3 {
-                eprintln!(
+                #[cfg(feature = "std")]
+                std::eprintln!(
                     "      initial group {}, [{} .. {}], has {} syms ({:4.1}%)",
                     nPart,
                     gs,
@@ -444,15 +448,18 @@ fn sendMTFValues(s: &mut EState) {
         }
 
         if s.verbosity >= 3 {
-            eprint!(
+            #[cfg(feature = "std")]
+            std::eprint!(
                 "      pass {}: size is {}, grp uses are ",
                 iter + 1,
                 totc / 8,
             );
             for t in 0..nGroups {
-                eprint!("{} ", fave[t],);
+                #[cfg(feature = "std")]
+                std::eprint!("{} ", fave[t],);
             }
-            eprintln!();
+            #[cfg(feature = "std")]
+            std::eprintln!();
         }
 
         /*--
@@ -532,7 +539,8 @@ fn sendMTFValues(s: &mut EState) {
             }
         }
         if s.verbosity >= 3 {
-            eprint!("      bytes: mapping {}, ", writer.num_z as i32 - nBytes,);
+            #[cfg(feature = "std")]
+            std::eprint!("      bytes: mapping {}, ", writer.num_z as i32 - nBytes,);
         }
     }
 
@@ -548,7 +556,8 @@ fn sendMTFValues(s: &mut EState) {
         writer.write(1, 0);
     }
     if s.verbosity >= 3 {
-        eprint!("selectors {}, ", writer.num_z as i32 - nBytes);
+        #[cfg(feature = "std")]
+        std::eprint!("selectors {}, ", writer.num_z as i32 - nBytes);
     }
 
     /*--- Now the coding tables. ---*/
@@ -570,7 +579,8 @@ fn sendMTFValues(s: &mut EState) {
         }
     }
     if s.verbosity >= 3 {
-        eprint!("code lengths {}, ", writer.num_z as i32 - nBytes);
+        #[cfg(feature = "std")]
+        std::eprint!("code lengths {}, ", writer.num_z as i32 - nBytes);
     }
 
     /*--- And finally, the block data proper ---*/
@@ -631,7 +641,8 @@ fn sendMTFValues(s: &mut EState) {
     assert_h!(selCtr == nSelectors, 3007);
 
     if s.verbosity >= 3 {
-        eprintln!("codes {}", writer.num_z as i32 - nBytes);
+        #[cfg(feature = "std")]
+        std::eprintln!("codes {}", writer.num_z as i32 - nBytes);
     }
 }
 
@@ -645,9 +656,13 @@ pub fn BZ2_compressBlock(s: &mut EState, is_last_block: bool) {
         }
 
         if s.verbosity >= 2 {
-            eprintln!(
+            #[cfg(feature = "std")]
+            std::eprintln!(
                 "    block {}: crc = 0x{:08x}, combined CRC = 0x{:08x}, size = {}",
-                s.blockNo, s.blockCRC, s.combinedCRC, s.nblock,
+                s.blockNo,
+                s.blockCRC,
+                s.combinedCRC,
+                s.nblock,
             );
         }
 
@@ -713,7 +728,8 @@ pub fn BZ2_compressBlock(s: &mut EState, is_last_block: bool) {
         writer.write_u32(s.combinedCRC);
 
         if s.verbosity >= 2 {
-            eprint!("    final combined CRC = 0x{:08x}\n   ", s.combinedCRC);
+            #[cfg(feature = "std")]
+            std::eprint!("    final combined CRC = 0x{:08x}\n   ", s.combinedCRC);
         }
 
         writer.finish();

diff --git a/decompress.rs b/decompress.rs
@@ -565,7 +565,8 @@ pub fn BZ2_decompress(strm: &mut bz_stream, s: &mut DState) -> ReturnCode {
 
                 s.currBlockNo += 1;
                 if s.verbosity >= 2 {
-                    eprint!("\n    [{}: huff+mtf ", s.currBlockNo);
+                    #[cfg(feature = "std")]
+                    std::eprint!("\n    [{}: huff+mtf ", s.currBlockNo);
                 }
                 s.storedBlockCRC = 0_u32;
                 current_block = BZ_X_BCRC_1;
@@ -1062,7 +1063,8 @@ pub fn BZ2_decompress(strm: &mut bz_stream, s: &mut DState) -> ReturnCode {
                             s.calculatedBlockCRC = 0xffffffffu32;
                             s.state = State::BZ_X_OUTPUT;
                             if s.verbosity >= 2 {
-                                eprint!("rt+rld");
+                                #[cfg(feature = "std")]
+                                std::eprint!("rt+rld");
                             }
                             match s.smallDecompress {
                                 DecompressMode::Small => {

diff --git a/test-libbzip2-rs-sys/Cargo.toml b/test-libbzip2-rs-sys/Cargo.toml
@@ -12,5 +12,5 @@ edition.workspace = true
 
 [dependencies]
 bzip2-sys = { version = "0.1.11", features = ["static"] }
-libbzip2-rs-sys = { workspace = true, default-features = false, features = ["testing-prefix"] }
+libbzip2-rs-sys = { workspace = true, default-features = true, features = ["testing-prefix"] }
 libc.workspace = true