Fix typo in expect message

src/lib.rs

@@ -56,7 +56,7 @@
     } else {
         grow(stack_size, callback)
     }
 }
 
 /// Always creates a new stack for the passed closure to run on.
 /// The closure will still be on the same thread as the caller of `grow`.
@@ -95,7 +95,7 @@
 psm_stack_information!(
     yes {
         fn current_stack_ptr() -> usize {
             psm::stack_pointer() as usize
         }
     }
     no {
@@ -106,7 +106,7 @@
                 // Unlikely to be ever exercised. As a fallback we execute a volatile read to a
                 // local (to hopefully defeat the optimisations that would make this local a static
                 // global) and take its address. This way we get a very approximate address of the
                 // current frame.
                 x.as_mut_ptr().write_volatile(42);
                 x.as_ptr() as usize
             }
@@ -177,7 +177,7 @@
                 let result = libc::mprotect(
                     above_guard_page,
                     stack_bytes - page_size,
                     libc::PROT_READ | libc::PROT_WRITE
                 );
                 #[cfg(target_os = "openbsd")]
                 let result = if libc::mmap(
@@ -231,7 +231,7 @@
                 .expect("unreasonably large stack requested") / page_size;
             let stack_pages = std::cmp::max(1, requested_pages) + 2;
             let stack_bytes = stack_pages.checked_mul(page_size)
-                .expect("unreasonably large stack requesteed");
+                .expect("unreasonably large stack requested");
 
             // Next, there are a couple of approaches to how we allocate the new stack. We take the
             // most obvious path and use `mmap`. We also `mprotect` a guard page into our
@@ -249,7 +249,7 @@
                 let panic = psm::on_stack(above_guard_page as *mut _, stack_size, move || {
                     std::panic::catch_unwind(std::panic::AssertUnwindSafe(callback)).err()
                 });
                 drop(guard);
                 if let Some(p) = panic {
                     std::panic::resume_unwind(p);
                 }
@@ -314,7 +314,7 @@
         }
 
         fn _grow(stack_size: usize, callback: &mut dyn FnMut()) {
             // Fibers (or stackful coroutines) is the only official way to create new stacks on the
             // same thread on Windows. So in order to extend the stack we create fiber and switch
             // to it so we can use it's stack. After running `callback` within our fiber, we switch
             // back to the current stack and destroy the fiber and its associated stack.
@@ -334,7 +334,7 @@
                             // regular threads, but they have associated fiber data. We later
                             // convert it back to a regular thread and free the fiber data.
                             ConvertThreadToFiber(ptr::null_mut())
                         }
                     },
                 };
 
@@ -355,7 +355,7 @@
                 // fiber_proc on it. fiber_proc will run `callback` and then switch back to run the
                 // next statement.
                 SwitchToFiber(fiber);
                 DeleteFiber(fiber);
 
                 // Clean-up.
                 if !was_fiber && ConvertFiberToThread() == 0 {
@@ -377,7 +377,7 @@
                 0x2000
             };
             let mut stack_guarantee = 0;
             unsafe {
                 // Read the current thread stack guarantee
                 // This is the stack reserved for stack overflow
                 // exception handling.
@@ -399,7 +399,7 @@
             type QueryT = windows_sys::Win32::System::Memory::MEMORY_BASIC_INFORMATION;
             let mut mi = std::mem::MaybeUninit::<QueryT>::uninit();
             VirtualQuery(
                 psm::stack_pointer() as *const _,
                 mi.as_mut_ptr(),
                 std::mem::size_of::<QueryT>() as usize,
             );