From 50b3e9e2678fb89c4c99cc4f78762d7a29852d2a Mon Sep 17 00:00:00 2001 From: Kornel Date: Thu, 26 Jan 2023 17:00:12 +0000 Subject: [PATCH] Use 16-bit lengths on 16-bit targets --- src/array_string.rs | 4 ++-- src/arrayvec.rs | 4 ++-- src/lib.rs | 9 ++++++++- tests/tests.rs | 9 +++------ 4 files changed, 15 insertions(+), 11 deletions(-) diff --git a/src/array_string.rs b/src/array_string.rs index 5c3414fc..bb7844bc 100644 --- a/src/array_string.rs +++ b/src/array_string.rs @@ -25,8 +25,8 @@ use serde::{Serialize, Deserialize, Serializer, Deserializer}; /// The `ArrayString` is a string backed by a fixed size array. It keeps track /// of its length, and is parameterized by `CAP` for the maximum capacity. /// -/// `CAP` is of type `usize` but is range limited to `u32::MAX`; attempting to create larger -/// arrayvecs with larger capacity will panic. +/// `CAP` is of type `usize` but is range limited to `u32::MAX` (or `u16` on 16-bit targets); +/// attempting to create larger arrayvecs with larger capacity will panic. /// /// The string is a contiguous value that you can store directly on the stack /// if needed. diff --git a/src/arrayvec.rs b/src/arrayvec.rs index a21bbb37..eb1db07f 100644 --- a/src/arrayvec.rs +++ b/src/arrayvec.rs @@ -31,8 +31,8 @@ use crate::utils::MakeMaybeUninit; /// the number of initialized elements. The `ArrayVec` is parameterized /// by `T` for the element type and `CAP` for the maximum capacity. /// -/// `CAP` is of type `usize` but is range limited to `u32::MAX`; attempting to create larger -/// arrayvecs with larger capacity will panic. +/// `CAP` is of type `usize` but is range limited to `u32::MAX` (or `u16::MAX` on 16-bit targets); +/// attempting to create larger arrayvecs with larger capacity will panic. /// /// The vector is a contiguous value (storing the elements inline) that you can store directly on /// the stack if needed. diff --git a/src/lib.rs b/src/lib.rs index 5dc0273a..3aa38d98 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -24,13 +24,20 @@ extern crate serde; #[cfg(not(feature="std"))] extern crate core as std; +#[cfg(not(target_pointer_width = "16"))] pub(crate) type LenUint = u32; +#[cfg(target_pointer_width = "16")] +pub(crate) type LenUint = u16; + macro_rules! assert_capacity_limit { ($cap:expr) => { if std::mem::size_of::() > std::mem::size_of::() { if $cap > LenUint::MAX as usize { - panic!("ArrayVec: largest supported capacity is u32::MAX") + #[cfg(not(target_pointer_width = "16"))] + panic!("ArrayVec: largest supported capacity is u32::MAX"); + #[cfg(target_pointer_width = "16")] + panic!("ArrayVec: largest supported capacity is u16::MAX"); } } } diff --git a/tests/tests.rs b/tests/tests.rs index 2f8a5ef5..8a5beba4 100644 --- a/tests/tests.rs +++ b/tests/tests.rs @@ -680,6 +680,7 @@ fn test_pop_at() { } #[test] +#[cfg(not(target_pointer_width = "16"))] fn test_sizes() { let v = ArrayVec::from([0u8; 1 << 16]); assert_eq!(vec![0u8; v.len()], &v[..]); @@ -743,21 +744,17 @@ fn allow_max_capacity_arrayvec_type() { } #[should_panic(expected="largest supported capacity")] +#[cfg(not(target_pointer_width = "16"))] #[test] fn deny_max_capacity_arrayvec_value() { - if mem::size_of::() <= mem::size_of::() { - panic!("This test does not work on this platform. 'largest supported capacity'"); - } // this type is allowed to be used (but can't be constructed) let _v: ArrayVec<(), {usize::MAX}> = ArrayVec::new(); } #[should_panic(expected="index out of bounds")] +#[cfg(not(target_pointer_width = "16"))] #[test] fn deny_max_capacity_arrayvec_value_const() { - if mem::size_of::() <= mem::size_of::() { - panic!("This test does not work on this platform. 'index out of bounds'"); - } // this type is allowed to be used (but can't be constructed) let _v: ArrayVec<(), {usize::MAX}> = ArrayVec::new_const(); }