fix windows compilation with c_alloc

Author: echohumm

.github/workflows/test.yml

@@ -43,10 +43,12 @@ jobs:
 
       - name: Run all tests
         if: steps.install_rust.outcome == 'success'
+        continue-on-error: false
         run: cargo +${{ matrix.rust }} test --verbose --features ${{ matrix.features }}
 
       - name: Run Miri
         if: matrix.rust == 'nightly' && steps.install_rust.outcome == 'success'
+        continue-on-error: false
         env:
           MIRIFLAGS: -Zmiri-permissive-provenance
         run: cargo +${{ matrix.rust }} miri test --verbose --features ${{ matrix.features }}

CHANGELOG.md

@@ -11,7 +11,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
-## [0.11.3]
+## [0.11.3] - 2026-02-15
+
+### Fixed
+
+* Crate failing to compile on Windows with the `c_alloc` feature
+
+## [0.11.3] - 2026-02-15
 
 ### Fixed
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "memapi2"
-version = "0.11.3"
+version = "0.11.4"
 edition = "2018"
 rust-version = "1.46.0"
 authors = ["echohumm"]

README.md

@@ -6,7 +6,7 @@
 A small, `no_std`/`no_alloc`-friendly allocation interface for raw buffers, with explicit layouts,
 split allocator traits, and structured errors.
 
-Version: 0.11.3
+Version: 0.11.4
 MSRV: 1.46.0 (some features require newer compilers or nightly; see [Feature flags](#feature-flags))
 
 ## Highlights
@@ -31,14 +31,14 @@ MSRV: 1.46.0 (some features require newer compilers or nightly; see [Feature fla
 
 ```toml
 [dependencies]
-memapi2 = "0.11.3"
+memapi2 = "0.11.4"
 ```
 
 If you want common optional features:
 
 ```toml
 [dependencies]
-memapi2 = { version = "0.11.3", features = ["os_err_reporting"] }
+memapi2 = { version = "0.11.4", features = ["os_err_reporting"] }
 ```
 
 ## Example

src/allocs/c_alloc.rs

@@ -1,12 +1,11 @@
 use {
     crate::{
         error::{Cause, Error},
-        ffi::c_alloc::{c_alloc, c_dealloc, c_zalloc, grow_aligned, shrink_aligned}
-        ,
+        ffi::c_alloc::{c_alloc, c_dealloc, c_zalloc, grow_aligned, shrink_aligned},
         layout::Layout,
         traits::{
-            alloc::{Alloc, Dealloc, Grow, Realloc, Shrink},
-            AllocError
+            AllocError,
+            alloc::{Alloc, Dealloc, Grow, Realloc, Shrink}
         }
     },
     ::core::{
@@ -106,7 +105,9 @@ unsafe fn pad_then_realloc(
         match old_size.cmp(&new_padded.size()) {
             // SAFETY: caller guarantees that `old_ptr` and `old_size` are valid, we just
             // checked that `size >= old_size`
-            Ordering::Less => unsafe { grow_aligned(old_ptr, old_align, old_size, align, size, zeroed) },
+            Ordering::Less => unsafe {
+                grow_aligned(old_ptr, old_align, old_size, align, size, zeroed)
+            },
             Ordering::Equal => {
                 if align > old_align {
                     // SAFETY: above
@@ -117,7 +118,9 @@ unsafe fn pad_then_realloc(
             }
             // SAFETY: caller guarantees that `old_ptr` and `size` are valid, we just checked
             // that `size <= old_size`
-            Ordering::Greater => unsafe { shrink_aligned(old_ptr, old_align, align, size) }
+            Ordering::Greater => unsafe {
+                shrink_aligned(old_ptr, old_align, old_size, align, size)
+            }
         }
     })
 }
@@ -157,7 +160,7 @@ impl Dealloc for CAlloc {
             Err(Error::DanglingDeallocation)
         } else {
             let padded = tri!(do layout.to_posix_memalign_compatible());
-            c_dealloc(ptr.as_ptr().cast(), padded.align());
+            c_dealloc(ptr.as_ptr().cast(), padded.align(), padded.size());
             Ok(())
         }
     }
@@ -196,7 +199,13 @@ impl Shrink for CAlloc {
         let new_padded = tri!(do new_layout.to_posix_memalign_compatible());
 
         null_q_dyn_zsl_check_or_errcode(new_layout, |_| {
-            shrink_aligned(ptr.as_ptr().cast(), old_padded.align(), new_padded.align(), new_padded.size())
+            shrink_aligned(
+                ptr.as_ptr().cast(),
+                old_padded.align(),
+                old_padded.size(),
+                new_padded.align(),
+                new_padded.size()
+            )
         })
     }
 }

src/ffi/c_alloc.rs

@@ -130,17 +130,23 @@ const NULL: *mut c_void = null_mut();
 ///
 /// - `old_ptr` must point to a C allocation of at least `size` bytes.
 /// - `ptr` must point to an allocation of at least `size` bytes.
-pub unsafe fn try_move(ptr: *mut c_void, old_ptr: *mut c_void, size: usize, old_align: usize) {
+pub unsafe fn try_move(
+    ptr: *mut c_void,
+    old_ptr: *mut c_void,
+    copy_count: usize,
+    old_align: usize,
+    old_size: usize
+) {
     if ptr != NULL {
         // SAFETY: `ptr` validated nonnull, caller guarantees `old_ptr` is valid. caller guarantees
         // `size` is <= size of allocation at `ptr` and <= size of allocation at `old_ptr`,
         // so copying that many bytes is safe.
         unsafe {
-            memcpy(ptr, old_ptr, size);
+            memcpy(ptr, old_ptr, copy_count);
         }
         // SAFETY: caller guarantees that `old_ptr` is valid
         unsafe {
-            c_dealloc(old_ptr, old_align);
+            c_dealloc(old_ptr, old_align, old_size);
         }
     }
 }
@@ -249,11 +255,11 @@ pub unsafe fn c_zalloc(align: usize, size: usize) -> (*mut c_void, c_int) {
 /// - `ptr` points to the start of a valid allocation returned by an allocation function listed
 ///   above, or is `NULL`.
 /// - `ptr` has not yet been deallocated.
-pub unsafe fn c_dealloc(ptr: *mut c_void, _align: usize) {
+pub unsafe fn c_dealloc(ptr: *mut c_void, _size: usize, _align: usize) {
     #[cfg(windows)]
     {
         #[allow(clippy::used_underscore_binding)]
-        if _align > MIN_ALIGN && size >= align {
+        if _align > MIN_ALIGN && _size >= _align {
             // SAFETY: requirements are passed onto the caller; as align > MIN_ALIGN,
             // _aligned_{malloc,realloc} was used so _aligned_free works.
             unsafe {
@@ -316,7 +322,7 @@ pub unsafe fn grow_aligned(
     // if successful, move data to new pointer
     // SAFETY: requirements are passed on to the caller
     unsafe {
-        try_move(ptr, old_ptr, old_size, old_align);
+        try_move(ptr, old_ptr, old_size, old_align, old_size);
     }
 
     (ptr, status)
@@ -346,6 +352,7 @@ pub unsafe fn grow_aligned(
 pub unsafe fn shrink_aligned(
     old_ptr: *mut c_void,
     old_align: usize,
+    old_size: usize,
     align: usize,
     size: usize // a zero here is useless, as it will just be overwritten anyway.
 ) -> (*mut c_void, c_int) {
@@ -357,7 +364,7 @@ pub unsafe fn shrink_aligned(
     // if successful, move data to new pointer
     // SAFETY: requirements are passed on to the caller
     unsafe {
-        try_move(ptr, old_ptr, size, old_align);
+        try_move(ptr, old_ptr, size, old_align, old_size);
     }
 
     (ptr, status)
@@ -426,7 +433,6 @@ extern "C" {
                   will leak memory"]
     pub fn aligned_alloc(align: usize, size: usize) -> *mut c_void;
 
-    #[cfg(not(windows))]
     /// Frees memory previously returned by the primary C allocator.
     ///
     /// The closest Rust equivalent is [`dealloc`](::stdalloc::alloc::dealloc).

src/lib.rs

@@ -88,8 +88,8 @@
 
 extern crate core;
 extern crate rustversion;
-#[cfg(feature = "c_alloc")]
-extern crate cty;
+
+#[cfg(feature = "c_alloc")] extern crate cty;
 
 #[cfg(not(feature = "no_alloc"))] extern crate alloc as stdalloc;
 #[cfg(all(feature = "std", feature = "no_alloc"))] extern crate std as stdalloc;